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

localization/strings/en-US/Resources.resw

@@ -2394,6 +2394,9 @@ On first run, creates the file with all settings commented out at their defaults
   <data name="WSLCCLI_VolumeArgDescription" xml:space="preserve">
     <value>Bind mount a volume to the container</value>
   </data>
+  <data name="WSLCCLI_WorkingDirArgDescription" xml:space="preserve">
+    <value>Working directory inside the container</value>
+  </data>
   <data name="WSLCCLI_CIDFileArgDescription" xml:space="preserve">
     <value>Write the container ID to the provided path.</value>
   </data>

src/windows/wslc/arguments/ArgumentDefinitions.h

@@ -79,7 +79,8 @@ _(Time,           "time",                L"t",              Kind::Value,       L
 _(TTY,            "tty",                 L"t",              Kind::Flag,        Localization::WSLCCLI_TTYArgDescription()) \
 /*_(User,           "user",                L"u",              Kind::Value,       Localization::WSLCCLI_UserArgDescription())*/ \
 _(Verbose,        "verbose",             L"v",              Kind::Flag,        Localization::WSLCCLI_VerboseArgDescription()) \
-_(Version,        "version",             L"v",              Kind::Flag,        Localization::WSLCCLI_VersionArgDescription()) \
+_(Version,        "version",             NO_ALIAS,              Kind::Flag,        Localization::WSLCCLI_VersionArgDescription()) \
 /*_(Virtual,        "virtualization",      NO_ALIAS,          Kind::Value,       Localization::WSLCCLI_VirtualArgDescription())*/ \
 _(Volume,         "volume",              L"v",              Kind::Value,       Localization::WSLCCLI_VolumeArgDescription()) \
+_(WorkDir,        "workdir",             L"w",              Kind::Value,       Localization::WSLCCLI_WorkDirArgDescription()) \
 // clang-format on

src/windows/wslc/arguments/ArgumentValidation.cpp

@@ -47,6 +47,16 @@ void Argument::Validate(const ArgMap& execArgs) const
         validation::ValidateVolumeMount(execArgs.GetAll<ArgType::Volume>());
         break;
 
+    case ArgType::WorkDir:
+    {
+        const auto& value = execArgs.Get<ArgType::WorkDir>();
+        if (value.empty() || std::all_of(value.begin(), value.end(), std::iswspace))
+        {
+            throw ArgumentException(std::format(L"Invalid {} argument value: working directory cannot be empty or whitespace", m_name));
+        }
+        break;
+    }
+
     default:
         break;
     }

src/windows/wslc/commands/ContainerExecCommand.cpp

@@ -37,6 +37,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

@@ -396,9 +396,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,12 @@ 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"exec --workdir \"\" cont1 echo Hello", L"exec", false) // Empty working directory
 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,76 @@ 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 "" cont1 cmd' rejects empty working directory
+    TEST_METHOD(ExecCommand_ParseWorkDirEmptyValue_ThrowsArgumentException)
+    {
+        // Invoke ContainerExecCommand parsing directly with the subcommand arguments it accepts.
+        auto invocation = CreateInvocationFromCommandLine(L"wslc --workdir \"\" cont1 sh");
+
+        ContainerExecCommand command{L""};
+        CLIExecutionContext context;
+        command.ParseArguments(invocation, context.Args);
+
+        VERIFY_THROWS_SPECIFIC(
+            command.ValidateArguments(context.Args), wsl::windows::wslc::ArgumentException, [](const auto&) { return true; });
+    }
+
+    // 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.

test/windows/wslc/e2e/WSLCE2EContainerExecTests.cpp

@@ -0,0 +1,126 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    WSLCE2EContainerExecTests.cpp
+
+Abstract:
+
+    This file contains end-to-end tests for WSLC container exec command.
+--*/
+
+#include "precomp.h"
+#include "windows/Common.h"
+#include "WSLCExecutor.h"
+#include "WSLCE2EHelpers.h"
+
+namespace WSLCE2ETests {
+
+class WSLCE2EContainerExecTests
+{
+    WSLC_TEST_CLASS(WSLCE2EContainerExecTests)
+
+    TEST_CLASS_SETUP(ClassSetup)
+    {
+        EnsureImageIsLoaded(DebianImage);
+        return true;
+    }
+
+    TEST_CLASS_CLEANUP(ClassCleanup)
+    {
+        EnsureContainerDoesNotExist(WslcContainerName);
+        EnsureImageIsDeleted(DebianImage);
+        return true;
+    }
+
+    TEST_METHOD_SETUP(TestMethodSetup)
+    {
+        EnsureContainerDoesNotExist(WslcContainerName);
+        return true;
+    }
+
+    TEST_METHOD(WSLCE2E_Container_Exec_HelpCommand)
+    {
+        WSL2_TEST_ONLY();
+
+        auto result = RunWslc(L"container exec --help");
+        result.Verify({.Stdout = GetHelpMessage(), .Stderr = L"", .ExitCode = 0});
+    }
+
+    TEST_METHOD(WSLCE2E_Container_Exec_WorkDir)
+    {
+        WSL2_TEST_ONLY();
+
+        auto result = RunWslc(std::format(L"container run -d --name {} {} sleep infinity", WslcContainerName, DebianImage.NameAndTag()));
+        result.Verify({.Stderr = L"", .ExitCode = 0});
+
+        result = RunWslc(std::format(L"container exec --workdir /tmp {} pwd", WslcContainerName));
+        result.Verify({.Stdout = L"/tmp\n", .Stderr = L"", .ExitCode = 0});
+    }
+
+    TEST_METHOD(WSLCE2E_Container_Exec_WorkDir_ShortAlias)
+    {
+        WSL2_TEST_ONLY();
+
+        auto result = RunWslc(std::format(L"container run -d --name {} {} sleep infinity", WslcContainerName, DebianImage.NameAndTag()));
+        result.Verify({.Stderr = L"", .ExitCode = 0});
+
+        result = RunWslc(std::format(L"container exec -w /tmp {} pwd", WslcContainerName));
+        result.Verify({.Stdout = L"/tmp\n", .Stderr = L"", .ExitCode = 0});
+    }
+
+private:
+    const std::wstring WslcContainerName = L"wslc-test-container";
+    const TestImage& DebianImage = DebianTestImage();
+
+    std::wstring GetHelpMessage() const
+    {
+        std::wstringstream output;
+        output << GetWslcHeader()        //
+               << GetDescription()       //
+               << GetUsage()             //
+               << GetAvailableCommands() //
+               << GetAvailableOptions();
+        return output.str();
+    }
+
+    std::wstring GetDescription() const
+    {
+        return L"Executes a command in a running container.\r\n\r\n";
+    }
+
+    std::wstring GetUsage() const
+    {
+        return L"Usage: wslc container exec [<options>] <container-id> <command> [<arguments>...]\r\n\r\n";
+    }
+
+    std::wstring GetAvailableCommands() const
+    {
+        std::wstringstream commands;
+        commands << L"The following arguments are available:\r\n"
+                 << L"  container-id      Container ID\r\n"
+                 << L"  command           The command to run\r\n"
+                 << L"  arguments         Arguments to pass to the command being executed inside the container\r\n"
+                 << L"\r\n";
+        return commands.str();
+    }
+
+    std::wstring GetAvailableOptions() const
+    {
+        std::wstringstream options;
+        options << L"The following options are available:\r\n"
+                << L"  -d,--detach       Run container in detached mode\r\n"
+                << L"  -e,--env          Key=Value pairs for environment variables\r\n"
+                << L"  --env-file        File containing key=value pairs of env variables\r\n"
+                << L"  -i,--interactive  Attach to stdin and keep it open\r\n"
+                << L"  --session         Specify the session to use\r\n"
+                << L"  -t,--tty          Open a TTY with the container process.\r\n"
+                << L"  -w,--workdir      Working directory inside the container\r\n"
+                << L"  -h,--help         Shows help about the selected command\r\n"
+                << L"\r\n";
+        return options.str();
+    }
+};
+} // namespace WSLCE2ETests