🤖 feat: improve Windows bash runtime detection with WSL support

- Add BashRuntime types (GitBashRuntime, WslRuntime, UnixBashRuntime)
- Detect available runtimes: WSL (preferred) and Git for Windows (fallback)
- Automatic Windows path translation for WSL (C:\ -> /mnt/c/)
- cwd embedded in script via 'cd' since WSL needs Linux paths
- Use -- separator to avoid WSL arg parsing issues
- Use absolute paths to bash for each runtime
- Always wrap commands in bash -c for consistent behavior
- Update BashExecutionService, execAsync, and LocalBaseRuntime
- Add comprehensive tests for runtime detection and path translation

_Generated with mux_

Author: ibetitsmike

docs/system-prompt.md

@@ -62,5 +62,4 @@ You are in a git worktree at ${workspacePath}
 }
 ```
 
-
 {/* END SYSTEM_PROMPT_DOCS */}

src/node/runtime/LocalBaseRuntime.ts

@@ -18,7 +18,7 @@ import type {
 } from "./Runtime";
 import { RuntimeError as RuntimeErrorClass } from "./Runtime";
 import { NON_INTERACTIVE_ENV_VARS } from "@/common/constants/env";
-import { getBashPath } from "@/node/utils/main/bashPath";
+import { getPreferredSpawnConfig } from "@/node/utils/main/bashPath";
 import { EXIT_CODE_ABORTED, EXIT_CODE_TIMEOUT } from "@/common/constants/exitCodes";
 import { DisposableProcess } from "@/node/utils/disposableExec";
 import { expandTilde } from "./tildeExpansion";
@@ -67,18 +67,26 @@ export abstract class LocalBaseRuntime implements Runtime {
       );
     }
 
+    // Get spawn config for the preferred bash runtime
+    // This handles Git for Windows, WSL, and Unix/macOS automatically
+    // For WSL, paths in the command and cwd are translated to /mnt/... format
+    const {
+      command: bashCommand,
+      args: bashArgs,
+      cwd: spawnCwd,
+    } = getPreferredSpawnConfig(command, cwd);
+
     // If niceness is specified on Unix/Linux, spawn nice directly to avoid escaping issues
     // Windows doesn't have nice command, so just spawn bash directly
     const isWindows = process.platform === "win32";
-    const bashPath = getBashPath();
-    const spawnCommand = options.niceness !== undefined && !isWindows ? "nice" : bashPath;
+    const spawnCommand = options.niceness !== undefined && !isWindows ? "nice" : bashCommand;
     const spawnArgs =
       options.niceness !== undefined && !isWindows
-        ? ["-n", options.niceness.toString(), bashPath, "-c", command]
-        : ["-c", command];
+        ? ["-n", options.niceness.toString(), bashCommand, ...bashArgs]
+        : bashArgs;
 
     const childProcess = spawn(spawnCommand, spawnArgs, {
-      cwd,
+      cwd: spawnCwd,
       env: {
         ...process.env,
         ...(options.env ?? {}),
@@ -367,9 +375,16 @@ export abstract class LocalBaseRuntime implements Runtime {
     const loggers = createLineBufferedLoggers(initLogger);
 
     return new Promise<void>((resolve) => {
-      const bashPath = getBashPath();
-      const proc = spawn(bashPath, ["-c", `"${hookPath}"`], {
-        cwd: workspacePath,
+      // Get spawn config for the preferred bash runtime
+      // For WSL, the hook path and cwd are translated to /mnt/... format
+      const {
+        command: bashCommand,
+        args: bashArgs,
+        cwd: spawnCwd,
+      } = getPreferredSpawnConfig(`"${hookPath}"`, workspacePath);
+
+      const proc = spawn(bashCommand, bashArgs, {
+        cwd: spawnCwd,
         stdio: ["ignore", "pipe", "pipe"],
         env: {
           ...process.env,

src/node/services/bashExecutionService.ts

@@ -1,7 +1,7 @@
 import { spawn } from "child_process";
 import type { ChildProcess } from "child_process";
 import { log } from "./log";
-import { getBashPath } from "@/node/utils/main/bashPath";
+import { getPreferredSpawnConfig } from "@/node/utils/main/bashPath";
 
 /**
  * Configuration for bash execution
@@ -121,17 +121,25 @@ export class BashExecutionService {
       `BashExecutionService: Script: ${script.substring(0, 100)}${script.length > 100 ? "..." : ""}`
     );
 
+    // Get spawn config for the preferred bash runtime
+    // This handles Git for Windows, WSL, and Unix/macOS automatically
+    // For WSL, paths in the script and cwd are translated to /mnt/... format
+    const {
+      command: bashCommand,
+      args: bashArgs,
+      cwd: spawnCwd,
+    } = getPreferredSpawnConfig(script, config.cwd);
+
     // Windows doesn't have nice command, so just spawn bash directly
     const isWindows = process.platform === "win32";
-    const bashPath = getBashPath();
-    const spawnCommand = config.niceness !== undefined && !isWindows ? "nice" : bashPath;
+    const spawnCommand = config.niceness !== undefined && !isWindows ? "nice" : bashCommand;
     const spawnArgs =
       config.niceness !== undefined && !isWindows
-        ? ["-n", config.niceness.toString(), bashPath, "-c", script]
-        : ["-c", script];
+        ? ["-n", config.niceness.toString(), bashCommand, ...bashArgs]
+        : bashArgs;
 
     const child = spawn(spawnCommand, spawnArgs, {
-      cwd: config.cwd,
+      cwd: spawnCwd,
       env: this.createBashEnvironment(config.secrets),
       stdio: ["ignore", "pipe", "pipe"],
       // Spawn as detached process group leader to prevent zombie processes

src/node/utils/disposableExec.ts

@@ -1,5 +1,6 @@
-import { exec } from "child_process";
+import { spawn } from "child_process";
 import type { ChildProcess } from "child_process";
+import { getPreferredSpawnConfig } from "@/node/utils/main/bashPath";
 
 /**
  * Disposable wrapper for child processes that ensures immediate cleanup.
@@ -117,12 +118,23 @@ class DisposableExec implements Disposable {
  * Execute command with automatic cleanup via `using` declaration.
  * Prevents zombie processes by ensuring child is reaped even on error.
  *
+ * Commands are always wrapped in `bash -c` for consistent behavior across platforms.
+ * On Windows, this uses the detected bash runtime (Git for Windows or WSL).
+ * For WSL, Windows paths in the command are automatically translated.
+ *
  * @example
  * using proc = execAsync("git status");
  * const { stdout } = await proc.result;
  */
 export function execAsync(command: string): DisposableExec {
-  const child = exec(command);
+  // Wrap command in bash -c for consistent cross-platform behavior
+  // For WSL, this also translates Windows paths to /mnt/... format
+  const { command: bashCmd, args } = getPreferredSpawnConfig(command);
+  const child = spawn(bashCmd, args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    // Prevent console window from appearing on Windows
+    windowsHide: true,
+  });
   const promise = new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
     let stdout = "";
     let stderr = "";

src/node/utils/main/bashPath.test.ts

@@ -0,0 +1,217 @@
+import { describe, it, expect } from "bun:test";
+import {
+  detectBashRuntimes,
+  getSpawnConfig,
+  getPreferredSpawnConfig,
+  isBashAvailable,
+  windowsToWslPath,
+  translateWindowsPathsInCommand,
+  type BashRuntime,
+} from "./bashPath";
+
+describe("bashPath", () => {
+  describe("detectBashRuntimes", () => {
+    it("should detect at least one runtime", () => {
+      const runtimes = detectBashRuntimes();
+      expect(runtimes.available.length).toBeGreaterThan(0);
+      expect(runtimes.preferred).toBeDefined();
+    });
+
+    it("should return unix runtime on non-Windows platforms", () => {
+      // This test runs on Linux/macOS CI
+      if (process.platform !== "win32") {
+        const runtimes = detectBashRuntimes();
+        expect(runtimes.preferred.type).toBe("unix");
+        expect(runtimes.available).toContainEqual({ type: "unix" });
+      }
+    });
+
+    it("should cache results", () => {
+      const first = detectBashRuntimes();
+      const second = detectBashRuntimes();
+      expect(first).toBe(second); // Same object reference
+    });
+  });
+
+  describe("getSpawnConfig", () => {
+    it("should generate correct config for unix runtime", () => {
+      const runtime: BashRuntime = { type: "unix" };
+      const config = getSpawnConfig(runtime, "echo hello");
+
+      expect(config.command).toBe("bash");
+      expect(config.args).toEqual(["-c", "echo hello"]);
+    });
+
+    it("should generate correct config for git-bash runtime", () => {
+      const runtime: BashRuntime = {
+        type: "git-bash",
+        bashPath: "C:\\Program Files\\Git\\bin\\bash.exe",
+      };
+      const config = getSpawnConfig(runtime, "echo hello");
+
+      expect(config.command).toBe("C:\\Program Files\\Git\\bin\\bash.exe");
+      expect(config.args).toEqual(["-c", "echo hello"]);
+    });
+
+    it("should generate correct config for wsl runtime with distro", () => {
+      const runtime: BashRuntime = { type: "wsl", distro: "Ubuntu" };
+      const config = getSpawnConfig(runtime, "echo hello");
+
+      expect(config.command).toBe("wsl");
+      expect(config.args).toContain("-d");
+      expect(config.args).toContain("Ubuntu");
+      expect(config.args).toContain("--");
+      expect(config.args).toContain("bash");
+      expect(config.args).toContain("-c");
+      expect(config.args[config.args.length - 1]).toContain("echo hello");
+    });
+
+    it("should generate correct config for wsl runtime without distro", () => {
+      const runtime: BashRuntime = { type: "wsl", distro: null };
+      const config = getSpawnConfig(runtime, "echo hello");
+
+      expect(config.command).toBe("wsl");
+      expect(config.args).not.toContain("-d");
+      expect(config.args).toContain("--");
+      expect(config.args).toContain("bash");
+      expect(config.args[config.args.length - 1]).toContain("echo hello");
+    });
+
+    it("should handle complex scripts with quotes and special characters", () => {
+      const runtime: BashRuntime = { type: "unix" };
+      const script = 'git commit -m "test message" && echo "done"';
+      const config = getSpawnConfig(runtime, script);
+
+      expect(config.args[1]).toBe(script);
+    });
+  });
+
+  describe("getPreferredSpawnConfig", () => {
+    it("should return valid spawn config", () => {
+      const config = getPreferredSpawnConfig("ls -la");
+
+      expect(config.command).toBeDefined();
+      expect(config.args).toBeArray();
+      expect(config.args.length).toBeGreaterThan(0);
+    });
+
+    it("should include the script in args", () => {
+      const script = "git status --porcelain";
+      const config = getPreferredSpawnConfig(script);
+
+      // Script should be in args (either directly or as part of -c arg)
+      expect(config.args.join(" ")).toContain(script);
+    });
+  });
+
+  describe("isBashAvailable", () => {
+    it("should return true when bash is available", () => {
+      // On CI (Linux), bash should always be available
+      if (process.platform !== "win32") {
+        expect(isBashAvailable()).toBe(true);
+      }
+    });
+  });
+
+  describe("windowsToWslPath", () => {
+    it("should convert C:\\ paths to /mnt/c/", () => {
+      expect(windowsToWslPath("C:\\Users\\micha\\source\\mux")).toBe(
+        "/mnt/c/Users/micha/source/mux"
+      );
+    });
+
+    it("should convert D:\\ paths to /mnt/d/", () => {
+      expect(windowsToWslPath("D:\\Projects\\myapp")).toBe("/mnt/d/Projects/myapp");
+    });
+
+    it("should handle lowercase drive letters", () => {
+      expect(windowsToWslPath("c:\\temp")).toBe("/mnt/c/temp");
+    });
+
+    it("should handle forward slashes in Windows paths", () => {
+      expect(windowsToWslPath("C:/Users/micha")).toBe("/mnt/c/Users/micha");
+    });
+
+    it("should return non-Windows paths unchanged", () => {
+      expect(windowsToWslPath("/home/user")).toBe("/home/user");
+      expect(windowsToWslPath("relative/path")).toBe("relative/path");
+    });
+
+    it("should handle paths with spaces", () => {
+      expect(windowsToWslPath("C:\\Program Files\\Git")).toBe("/mnt/c/Program Files/Git");
+    });
+  });
+
+  describe("translateWindowsPathsInCommand", () => {
+    it("should translate unquoted paths", () => {
+      expect(translateWindowsPathsInCommand("cd C:\\Users\\micha")).toBe("cd /mnt/c/Users/micha");
+    });
+
+    it("should translate double-quoted paths", () => {
+      expect(translateWindowsPathsInCommand('git -C "C:\\Users\\micha\\mux" status')).toBe(
+        'git -C "/mnt/c/Users/micha/mux" status'
+      );
+    });
+
+    it("should translate single-quoted paths", () => {
+      expect(translateWindowsPathsInCommand("ls 'D:\\Projects'")).toBe("ls '/mnt/d/Projects'");
+    });
+
+    it("should translate multiple paths in one command", () => {
+      expect(translateWindowsPathsInCommand('cp "C:\\src" "D:\\dest"')).toBe(
+        'cp "/mnt/c/src" "/mnt/d/dest"'
+      );
+    });
+
+    it("should leave non-Windows paths alone", () => {
+      const cmd = "ls /home/user && cat file.txt";
+      expect(translateWindowsPathsInCommand(cmd)).toBe(cmd);
+    });
+
+    it("should handle git -C commands", () => {
+      expect(
+        translateWindowsPathsInCommand('git -C "C:\\Users\\micha\\source\\mux" worktree list')
+      ).toBe('git -C "/mnt/c/Users/micha/source/mux" worktree list');
+    });
+  });
+
+  describe("getSpawnConfig with WSL path translation", () => {
+    it("should translate cwd for WSL runtime", () => {
+      const runtime: BashRuntime = { type: "wsl", distro: "Ubuntu" };
+      const config = getSpawnConfig(runtime, "ls", "C:\\Users\\micha");
+
+      // cwd is embedded in the script via 'cd' command
+      expect(config.cwd).toBeUndefined();
+      // The translated cwd should be in the bash script
+      const bashScript = config.args[config.args.length - 1];
+      expect(bashScript).toContain("/mnt/c/Users/micha");
+    });
+
+    it("should translate paths in script for WSL runtime", () => {
+      const runtime: BashRuntime = { type: "wsl", distro: null };
+      const config = getSpawnConfig(runtime, 'git -C "C:\\Projects\\app" status');
+
+      // The script has translated paths
+      const bashScript = config.args[config.args.length - 1];
+      expect(bashScript).toContain("/mnt/c/Projects/app");
+    });
+
+    it("should not translate paths for git-bash runtime", () => {
+      const runtime: BashRuntime = {
+        type: "git-bash",
+        bashPath: "C:\\Program Files\\Git\\bin\\bash.exe",
+      };
+      const config = getSpawnConfig(runtime, 'git -C "C:\\Projects" status', "C:\\Projects");
+
+      expect(config.cwd).toBe("C:\\Projects");
+      expect(config.args[1]).toBe('git -C "C:\\Projects" status');
+    });
+
+    it("should not translate paths for unix runtime", () => {
+      const runtime: BashRuntime = { type: "unix" };
+      const config = getSpawnConfig(runtime, "ls", "/home/user");
+
+      expect(config.cwd).toBe("/home/user");
+    });
+  });
+});