[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

@@ -78,8 +78,9 @@ _(Time,           "time",                L"t",              Kind::Value,       L
 /*_(TMPFS,          "tmpfs",               NO_ALIAS,          Kind::Value,       Localization::WSLCCLI_TMPFSArgDescription())*/ \
 _(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()) \
+_(Verbose,        "verbose",             NO_ALIAS,          Kind::Flag,        Localization::WSLCCLI_VerboseArgDescription()) \
 _(Version,        "version",             L"v",              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_WorkingDirArgDescription()) \
 // clang-format on

src/windows/wslc/arguments/ArgumentValidation.cpp

@@ -47,6 +47,17 @@ 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(), [](wchar_t c) { return std::iswspace(static_cast<wint_t>(c)); }))
+        {
+            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;
     std::optional<std::string> User{};
 };

src/windows/wslc/services/ContainerService.cpp

@@ -408,6 +408,10 @@ int ContainerService::Exec(Session& session, const std::string& id, ContainerOpt
         auto user = options.User.value();
         processLauncher.SetUser(std::move(user));
     }
+    if (!options.WorkingDirectory.empty())
+    {
+        processLauncher.SetWorkingDirectory(std::move(options.WorkingDirectory));
+    }
 
     return ConsoleService::AttachToCurrentConsole(processLauncher.Launch(*container));
 }

src/windows/wslc/tasks/ContainerTasks.cpp

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

@@ -26,7 +26,6 @@ COMMAND_LINE_TEST_CASE(L"-v", L"root", true)
 
 // Session command tests
 COMMAND_LINE_TEST_CASE(L"session list", L"list", true)
-COMMAND_LINE_TEST_CASE(L"session list -v", L"list", true)
 COMMAND_LINE_TEST_CASE(L"session list --verbose", L"list", true)
 COMMAND_LINE_TEST_CASE(L"session list --verbose --help", L"list", true)
 COMMAND_LINE_TEST_CASE(L"session list --notanarg", L"list", false)
@@ -68,6 +67,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)
@@ -98,7 +103,6 @@ COMMAND_LINE_TEST_CASE(L"image build C:\\context --tag tag1 --tag tag2 --tag tag
 COMMAND_LINE_TEST_CASE(L"image build C:\\context --build-arg KEY=VALUE", L"build", true)
 COMMAND_LINE_TEST_CASE(L"image build C:\\context --build-arg A=1 --build-arg B=2", L"build", true)
 COMMAND_LINE_TEST_CASE(L"image build C:\\context -t test:latest --build-arg KEY=VALUE -f Dockerfile.custom", L"build", true)
-COMMAND_LINE_TEST_CASE(L"image build C:\\context -v", L"build", true)
 COMMAND_LINE_TEST_CASE(L"image build C:\\context --verbose", L"build", true)
 COMMAND_LINE_TEST_CASE(L"image build C:\\context -t test --build-arg KEY=VALUE --verbose", L"build", true)
 COMMAND_LINE_TEST_CASE(L"image build", L"build", false)
@@ -110,7 +114,7 @@ COMMAND_LINE_TEST_CASE(L"images", L"images", true) // Aliased off the root chang
 COMMAND_LINE_TEST_CASE(L"image ls", L"list", true)
 COMMAND_LINE_TEST_CASE(L"image list --format json", L"list", true)
 COMMAND_LINE_TEST_CASE(L"image list --format badformat", L"list", false)
-COMMAND_LINE_TEST_CASE(L"image list -v", L"list", true)
+COMMAND_LINE_TEST_CASE(L"image list --verbose", L"list", true)
 COMMAND_LINE_TEST_CASE(L"image list -q", L"list", true)
 COMMAND_LINE_TEST_CASE(L"image pull ubuntu", L"pull", true)
 COMMAND_LINE_TEST_CASE(L"pull ubuntu", L"pull", true)

test/windows/wslc/ParserTestCases.h

@@ -89,14 +89,14 @@ WSLC_PARSER_TEST_CASE(Run, true, LR"(wslc -p=80:80 -p=443:443 cont1)") \
 WSLC_PARSER_TEST_CASE(Run, false, LR"(wslc --verbose --verbose cont1)") \
 \
 /* Flag parse tests */ \
-WSLC_PARSER_TEST_CASE(Run, true, LR"(wslc -v cont1)") \
-WSLC_PARSER_TEST_CASE(Run, true, LR"(wslc -vi cont1)") \
-WSLC_PARSER_TEST_CASE(Run, false, LR"(wslc -ivp- cont1)") \
-WSLC_PARSER_TEST_CASE(Run, false, LR"(wslc -piv cont1)") \
-WSLC_PARSER_TEST_CASE(Run, false, LR"(wslc -piv=80:80 cont1)") \
-WSLC_PARSER_TEST_CASE(Run, false, LR"(wslc -piv 80:80 cont1)") \
-WSLC_PARSER_TEST_CASE(Run, true, LR"(wslc -ivp 80:80 cont1)") \
-WSLC_PARSER_TEST_CASE(Run, true, LR"(wslc -ivp=80:80 cont1)") \
+WSLC_PARSER_TEST_CASE(Run, true, LR"(wslc -h cont1)") \
+WSLC_PARSER_TEST_CASE(Run, true, LR"(wslc -hi cont1)") \
+WSLC_PARSER_TEST_CASE(Run, false, LR"(wslc -ihp- cont1)") \
+WSLC_PARSER_TEST_CASE(Run, false, LR"(wslc -pih cont1)") \
+WSLC_PARSER_TEST_CASE(Run, false, LR"(wslc -pih=80:80 cont1)") \
+WSLC_PARSER_TEST_CASE(Run, false, LR"(wslc -pih 80:80 cont1)") \
+WSLC_PARSER_TEST_CASE(Run, true, LR"(wslc -ihp 80:80 cont1)") \
+WSLC_PARSER_TEST_CASE(Run, true, LR"(wslc -ihp=80:80 cont1)") \
 \
 /* Validation tests */ \
 WSLC_PARSER_TEST_CASE(Run, false, LR"(wslc --signal FOO cont1)") \

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,127 @@
+/*++
+
+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"  -u,--user         User ID for the process (name|uid|uid:gid)\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

test/windows/wslc/e2e/WSLCE2EImageListTests.cpp

@@ -173,12 +173,12 @@ class WSLCE2EImageListTests
     {
         std::wstringstream options;
         options << L"The following options are available:\r\n"
-                << L"  --format      " << Localization::WSLCCLI_FormatArgDescription() << L"\r\n"
-                << L"  --no-trunc    Do not truncate output\r\n"
-                << L"  -q,--quiet    Outputs the container IDs only\r\n"
-                << L"  --session     Specify the session to use\r\n"
-                << L"  -v,--verbose  Output verbose details\r\n"
-                << L"  -h,--help     Shows help about the selected command\r\n"
+                << L"  --format    " << Localization::WSLCCLI_FormatArgDescription() << L"\r\n"
+                << L"  --no-trunc  Do not truncate output\r\n"
+                << L"  -q,--quiet  Outputs the container IDs only\r\n"
+                << L"  --session   Specify the session to use\r\n"
+                << L"  --verbose   Output verbose details\r\n"
+                << L"  -h,--help   Shows help about the selected command\r\n"
                 << L"\r\n";
         return options.str();
     }