[WSLC] Add --workdir / -w option to 'wslc exec'

src/windows/wslc/arguments/ArgumentDefinitions.h

@@ -82,4 +82,5 @@ _(Verbose,        "verbose",             L"v",              Kind::Flag,        L
 _(Version,        "version",             L"v",              Kind::Flag,        L"Show version information for this tool") \
 /*_(Virtual,        "virtualization",      NO_ALIAS,          Kind::Value,       L"Expose virtualization capabilities to the container")*/ \
 _(Volume,         "volume",              L"v",              Kind::Value,       L"Bind mount a volume to the container") \
+_(WorkDir,        "workdir",             L"w",              Kind::Value,       L"Working directory inside the container") \
 // clang-format on

src/windows/wslc/commands/ContainerExecCommand.cpp

@@ -40,6 +40,7 @@ std::vector<Argument> ContainerExecCommand::GetArguments() const
         Argument::Create(ArgType::Session),
         Argument::Create(ArgType::TTY),
         // Argument::Create(ArgType::User),
+        Argument::Create(ArgType::WorkDir),
     };
 }
 

src/windows/wslc/services/ContainerModel.h

@@ -38,6 +38,7 @@ struct ContainerOptions
     bool TTY = false;
     std::vector<std::string> Ports;
     std::vector<std::wstring> Volumes;
+    std::string WorkingDirectory;
     std::vector<std::string> Entrypoint;
 };
 

src/windows/wslc/services/ContainerService.cpp

@@ -415,9 +415,14 @@ int ContainerService::Exec(Session& session, const std::string& id, ContainerOpt
     WI_SetFlagIf(execFlags, WSLCProcessFlagsStdin, options.Interactive);
     WI_SetFlagIf(execFlags, WSLCProcessFlagsTty, options.TTY);
 
+    wsl::windows::common::WSLCProcessLauncher launcher({}, options.Arguments, options.EnvironmentVariables, execFlags);
+    if (!options.WorkingDirectory.empty())
+    {
+        launcher.SetWorkingDirectory(std::move(options.WorkingDirectory));
+    }
+
     ConsoleService consoleService;
-    return consoleService.AttachToCurrentConsole(
-        wsl::windows::common::WSLCProcessLauncher({}, options.Arguments, options.EnvironmentVariables, execFlags).Launch(*container));
+    return consoleService.AttachToCurrentConsole(launcher.Launch(*container));
 }
 
 InspectContainer ContainerService::Inspect(Session& session, const std::string& id)

src/windows/wslc/tasks/ContainerTasks.cpp

@@ -288,6 +288,11 @@ void SetContainerOptionsFromArgs(CLIExecutionContext& context)
         }
     }
 
+    if (context.Args.Contains(ArgType::WorkDir))
+    {
+        options.WorkingDirectory = WideToMultiByte(context.Args.Get<ArgType::WorkDir>());
+    }
+
     context.Data.Add<Data::ContainerOptions>(std::move(options));
 }
 

test/windows/wslc/CommandLineTestCases.h

@@ -68,6 +68,11 @@ COMMAND_LINE_TEST_CASE(L"container create --name foo ubuntu", L"create", true)
 COMMAND_LINE_TEST_CASE(L"exec cont1 echo Hello", L"exec", true)
 COMMAND_LINE_TEST_CASE(L"exec cont1", L"exec", false)                                         // Missing required command argument
 COMMAND_LINE_TEST_CASE(L"container exec -it cont1 sh -c \"echo a && echo b\"", L"exec", true) // docker exec example
+COMMAND_LINE_TEST_CASE(L"exec --workdir /app cont1 echo Hello", L"exec", true)
+COMMAND_LINE_TEST_CASE(L"exec -w /app cont1 echo Hello", L"exec", true)
+COMMAND_LINE_TEST_CASE(L"container exec --workdir /app cont1 sh", L"exec", true)
+COMMAND_LINE_TEST_CASE(L"exec --workdir", L"exec", false)       // Missing value for --workdir
+COMMAND_LINE_TEST_CASE(L"exec cont1 --workdir", L"exec", false) // Invalid argument specifier after container id
 COMMAND_LINE_TEST_CASE(L"kill cont1 --signal sigkill", L"kill", true)
 COMMAND_LINE_TEST_CASE(L"container kill cont1 -s KILL", L"kill", true)
 COMMAND_LINE_TEST_CASE(L"inspect cont1", L"inspect", true)

test/windows/wslc/WSLCCLIExecutionUnitTests.cpp

@@ -20,6 +20,8 @@ Module Name:
 
 #include "Command.h"
 #include "RootCommand.h"
+#include "ContainerCommand.h"
+#include "ContainerTasks.h"
 
 using namespace wsl::windows::wslc;
 using namespace WSLCTestHelpers;
@@ -116,6 +118,62 @@ class WSLCCLIExecutionUnitTests
         // This one will just verify all the data types in the Data Map work as expected.
     }
 
+    // Test: SetContainerOptionsFromArgs sets WorkingDirectory when --workdir is provided
+    TEST_METHOD(SetContainerOptionsFromArgs_WithWorkDir_SetsWorkingDirectory)
+    {
+        CLIExecutionContext context;
+        context.Args.Add<ArgType::WorkDir>(std::wstring{L"/app"});
+
+        wsl::windows::wslc::task::SetContainerOptionsFromArgs(context);
+
+        const auto& options = context.Data.Get<Data::ContainerOptions>();
+        VERIFY_ARE_EQUAL(std::string("/app"), options.WorkingDirectory);
+    }
+
+    // Test: SetContainerOptionsFromArgs leaves WorkingDirectory empty when --workdir is not provided
+    TEST_METHOD(SetContainerOptionsFromArgs_WithoutWorkDir_WorkingDirectoryIsEmpty)
+    {
+        CLIExecutionContext context;
+
+        wsl::windows::wslc::task::SetContainerOptionsFromArgs(context);
+
+        const auto& options = context.Data.Get<Data::ContainerOptions>();
+        VERIFY_IS_TRUE(options.WorkingDirectory.empty());
+    }
+
+    // Test: Full parse of 'exec --workdir /path cont1 cmd' sets WorkingDirectory
+    TEST_METHOD(ExecCommand_ParseWorkDirLongOption_SetsWorkingDirectory)
+    {
+        // Invoke ContainerExecCommand parsing directly with the subcommand arguments it accepts.
+        auto invocation = CreateInvocationFromCommandLine(L"wslc --workdir /tmp/mydir cont1 sh");
+
+        ContainerExecCommand command{L""};
+        CLIExecutionContext context;
+        command.ParseArguments(invocation, context.Args);
+        command.ValidateArguments(context.Args);
+
+        wsl::windows::wslc::task::SetContainerOptionsFromArgs(context);
+
+        const auto& options = context.Data.Get<Data::ContainerOptions>();
+        VERIFY_ARE_EQUAL(std::string("/tmp/mydir"), options.WorkingDirectory);
+    }
+
+    // Test: Full parse of 'exec -w /path cont1 cmd' (short alias) sets WorkingDirectory
+    TEST_METHOD(ExecCommand_ParseWorkDirShortOption_SetsWorkingDirectory)
+    {
+        auto invocation = CreateInvocationFromCommandLine(L"wslc -w /app cont1 sh");
+
+        ContainerExecCommand command{L""};
+        CLIExecutionContext context;
+        command.ParseArguments(invocation, context.Args);
+        command.ValidateArguments(context.Args);
+
+        wsl::windows::wslc::task::SetContainerOptionsFromArgs(context);
+
+        const auto& options = context.Data.Get<Data::ContainerOptions>();
+        VERIFY_ARE_EQUAL(std::string("/app"), options.WorkingDirectory);
+    }
+
     // Test: Command Line test parsing all cases defined in CommandLineTestCases.h
     // This test verifies the command line parsing logic used by the CLI and executes the same
     // code as the CLI up to the point of command execution, including parsing and argument validtion.