🤖 refactor: DRY cleanup for Docker runtime implementation

Extract shared utilities and consolidate duplicate code:

1. streamUtils.ts - Extract streamToString helper used by SSH and Docker
2. streamUtils.ts - Extract shescape shell escaping helper used by SSH and Docker
3. initHook.ts - Add runInitHookOnRuntime() shared by SSH and Docker runtimes
4. chatCommands.ts - Use parseRuntimeModeAndHost from common/types/runtime

Net reduction: ~79 lines of duplicate code removed while improving maintainability.

_Generated with mux_

Author: ammar-agent

src/browser/utils/chatCommands.ts

@@ -16,7 +16,7 @@ import type {
 } from "@/common/types/message";
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
 import type { RuntimeConfig } from "@/common/types/runtime";
-import { RUNTIME_MODE, SSH_RUNTIME_PREFIX, DOCKER_RUNTIME_PREFIX } from "@/common/types/runtime";
+import { RUNTIME_MODE, parseRuntimeModeAndHost } from "@/common/types/runtime";
 import { CUSTOM_EVENTS, createCustomEvent } from "@/common/constants/events";
 import { WORKSPACE_ONLY_COMMANDS } from "@/constants/slashCommands";
 import type { Toast } from "@/browser/components/ChatInputToast";
@@ -430,7 +430,9 @@ async function handleForkCommand(
 }
 
 /**
- * Parse runtime string from -r flag into RuntimeConfig for backend
+ * Parse runtime string from -r flag into RuntimeConfig for backend.
+ * Uses shared parseRuntimeModeAndHost for parsing, then converts to RuntimeConfig.
+ *
  * Supports formats:
  * - "ssh <host>" or "ssh <user@host>" -> SSH runtime
  * - "docker <image>" -> Docker container runtime
@@ -442,57 +444,45 @@ export function parseRuntimeString(
   runtime: string | undefined,
   _workspaceName: string
 ): RuntimeConfig | undefined {
-  if (!runtime) {
-    return undefined; // Default to worktree (backend decides)
-  }
-
-  const trimmed = runtime.trim();
-  const lowerTrimmed = trimmed.toLowerCase();
-
-  // Worktree runtime (explicit or default)
-  if (lowerTrimmed === RUNTIME_MODE.WORKTREE) {
-    return undefined; // Explicit worktree - let backend use default
-  }
-
-  // Local runtime (project-dir, no isolation)
-  if (lowerTrimmed === RUNTIME_MODE.LOCAL) {
-    // Return "local" type without srcBaseDir to indicate project-dir runtime
-    return { type: RUNTIME_MODE.LOCAL };
-  }
-
-  // Parse "ssh <host>" or "ssh <user@host>" format
-  if (lowerTrimmed === RUNTIME_MODE.SSH || lowerTrimmed.startsWith(SSH_RUNTIME_PREFIX)) {
-    const hostPart = trimmed.slice(SSH_RUNTIME_PREFIX.length - 1).trim(); // Preserve original case for host
-    if (!hostPart) {
+  // Use shared parser from common/types/runtime
+  const parsed = parseRuntimeModeAndHost(runtime);
+
+  // null means invalid input (e.g., "ssh" without host, "docker" without image)
+  if (parsed === null) {
+    // Determine which error to throw based on input
+    const trimmed = runtime?.trim().toLowerCase() ?? "";
+    if (trimmed === RUNTIME_MODE.SSH || trimmed.startsWith("ssh ")) {
       throw new Error("SSH runtime requires host (e.g., 'ssh hostname' or 'ssh user@host')");
     }
-
-    // Accept both "hostname" and "user@hostname" formats
-    // SSH will use current user or ~/.ssh/config if user not specified
-    // Use tilde path - backend will resolve it via runtime.resolvePath()
-    return {
-      type: RUNTIME_MODE.SSH,
-      host: hostPart,
-      srcBaseDir: "~/mux", // Default remote base directory (tilde will be resolved by backend)
-    };
-  }
-
-  // Parse "docker <image>" format
-  if (lowerTrimmed === RUNTIME_MODE.DOCKER || lowerTrimmed.startsWith(DOCKER_RUNTIME_PREFIX)) {
-    const imagePart = trimmed.slice(DOCKER_RUNTIME_PREFIX.length - 1).trim(); // Preserve original case for image
-    if (!imagePart) {
+    if (trimmed === RUNTIME_MODE.DOCKER || trimmed.startsWith("docker ")) {
       throw new Error("Docker runtime requires image (e.g., 'docker ubuntu:22.04')");
     }
-
-    return {
-      type: RUNTIME_MODE.DOCKER,
-      image: imagePart,
-    };
+    throw new Error(
+      `Unknown runtime type: '${runtime ?? ""}'. Use 'ssh <host>', 'docker <image>', 'worktree', or 'local'`
+    );
   }
 
-  throw new Error(
-    `Unknown runtime type: '${runtime}'. Use 'ssh <host>', 'docker <image>', 'worktree', or 'local'`
-  );
+  // Convert ParsedRuntime to RuntimeConfig
+  switch (parsed.mode) {
+    case RUNTIME_MODE.WORKTREE:
+      return undefined; // Let backend use default worktree config
+
+    case RUNTIME_MODE.LOCAL:
+      return { type: RUNTIME_MODE.LOCAL };
+
+    case RUNTIME_MODE.SSH:
+      return {
+        type: RUNTIME_MODE.SSH,
+        host: parsed.host,
+        srcBaseDir: "~/mux", // Default remote base directory (tilde resolved by backend)
+      };
+
+    case RUNTIME_MODE.DOCKER:
+      return {
+        type: RUNTIME_MODE.DOCKER,
+        image: parsed.image,
+      };
+  }
 }
 
 export interface CreateWorkspaceOptions {

src/node/runtime/DockerRuntime.ts

@@ -28,29 +28,19 @@ import type {
 import { RuntimeError } from "./Runtime";
 import { EXIT_CODE_ABORTED, EXIT_CODE_TIMEOUT } from "@/common/constants/exitCodes";
 import { log } from "@/node/services/log";
-import { checkInitHookExists, createLineBufferedLoggers, getMuxEnv } from "./initHook";
+import { checkInitHookExists, getMuxEnv, runInitHookOnRuntime } from "./initHook";
 import { NON_INTERACTIVE_ENV_VARS } from "@/common/constants/env";
 import { getProjectName } from "@/node/utils/runtime/helpers";
 import { getErrorMessage } from "@/common/utils/errors";
 import { DisposableProcess } from "@/node/utils/disposableExec";
+import { streamToString, shescape } from "./streamUtils";
 
 /** Hardcoded source directory inside container */
 const CONTAINER_SRC_DIR = "/src";
 
 /** Hardcoded background output directory inside container */
 const _CONTAINER_BG_OUTPUT_DIR = "/tmp/mux-bashes";
 
-/**
- * Shell-escape helper for container bash.
- */
-const shescape = {
-  quote(value: unknown): string {
-    const s = String(value);
-    if (s.length === 0) return "''";
-    return "'" + s.replace(/'/g, "'\"'\"'") + "'";
-  },
-};
-
 /**
  * Result of running a Docker command
  */
@@ -568,7 +558,8 @@ export class DockerRuntime implements Runtime {
       const hookExists = await checkInitHookExists(projectPath);
       if (hookExists) {
         const muxEnv = getMuxEnv(projectPath, "docker", branchName);
-        await this.runInitHook(workspacePath, muxEnv, initLogger, abortSignal);
+        const hookPath = `${workspacePath}/.mux/init`;
+        await runInitHookOnRuntime(this, hookPath, workspacePath, muxEnv, initLogger, abortSignal);
       } else {
         initLogger.logComplete(0);
       }
@@ -724,61 +715,6 @@ export class DockerRuntime implements Runtime {
     }
   }
 
-  /**
-   * Run .mux/init hook inside container
-   */
-  private async runInitHook(
-    workspacePath: string,
-    muxEnv: Record<string, string>,
-    initLogger: InitLogger,
-    abortSignal?: AbortSignal
-  ): Promise<void> {
-    const hookPath = `${workspacePath}/.mux/init`;
-    initLogger.logStep(`Running init hook: ${hookPath}`);
-
-    const hookStream = await this.exec(hookPath, {
-      cwd: workspacePath,
-      timeout: 3600,
-      abortSignal,
-      env: muxEnv,
-    });
-
-    const loggers = createLineBufferedLoggers(initLogger);
-    const stdoutReader = hookStream.stdout.getReader();
-    const stderrReader = hookStream.stderr.getReader();
-    const decoder = new TextDecoder();
-
-    const readStdout = async () => {
-      try {
-        while (true) {
-          const { done, value } = await stdoutReader.read();
-          if (done) break;
-          loggers.stdout.append(decoder.decode(value, { stream: true }));
-        }
-        loggers.stdout.flush();
-      } finally {
-        stdoutReader.releaseLock();
-      }
-    };
-
-    const readStderr = async () => {
-      try {
-        while (true) {
-          const { done, value } = await stderrReader.read();
-          if (done) break;
-          loggers.stderr.append(decoder.decode(value, { stream: true }));
-        }
-        loggers.stderr.flush();
-      } finally {
-        stderrReader.releaseLock();
-      }
-    };
-
-    const [exitCode] = await Promise.all([hookStream.exitCode, readStdout(), readStderr()]);
-
-    initLogger.logComplete(exitCode);
-  }
-
   // eslint-disable-next-line @typescript-eslint/require-await
   async renameWorkspace(
     _projectPath: string,
@@ -877,23 +813,3 @@ export class DockerRuntime implements Runtime {
     return Promise.resolve("/tmp");
   }
 }
-/**
- * Helper to convert a ReadableStream to a string
- */
-async function streamToString(stream: ReadableStream<Uint8Array>): Promise<string> {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder("utf-8");
-  let result = "";
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      result += decoder.decode(value, { stream: true });
-    }
-    result += decoder.decode();
-    return result;
-  } finally {
-    reader.releaseLock();
-  }
-}

src/node/runtime/SSHRuntime.ts

@@ -17,7 +17,8 @@ import type {
 import { RuntimeError as RuntimeErrorClass } from "./Runtime";
 import { EXIT_CODE_ABORTED, EXIT_CODE_TIMEOUT } from "@/common/constants/exitCodes";
 import { log } from "@/node/services/log";
-import { checkInitHookExists, createLineBufferedLoggers, getMuxEnv } from "./initHook";
+import { checkInitHookExists, getMuxEnv, runInitHookOnRuntime } from "./initHook";
+import { expandTildeForSSH as expandHookPath } from "./tildeExpansion";
 import { NON_INTERACTIVE_ENV_VARS } from "@/common/constants/env";
 import { streamProcessToLogger } from "./streamProcess";
 import { expandTildeForSSH, cdCommandForSSH } from "./tildeExpansion";
@@ -26,20 +27,7 @@ import { getErrorMessage } from "@/common/utils/errors";
 import { execAsync, DisposableProcess } from "@/node/utils/disposableExec";
 import { getControlPath, sshConnectionPool, type SSHRuntimeConfig } from "./sshConnectionPool";
 import { getBashPath } from "@/node/utils/main/bashPath";
-
-/**
- * Shell-escape helper for remote bash.
- * Reused across all SSH runtime operations for performance.
- * Note: For background process commands, use shellQuote from backgroundCommands for parity.
- */
-const shescape = {
-  quote(value: unknown): string {
-    const s = String(value);
-    if (s.length === 0) return "''";
-    // Use POSIX-safe pattern to embed single quotes within single-quoted strings
-    return "'" + s.replace(/'/g, "'\"'\"'") + "'";
-  },
-};
+import { streamToString, shescape } from "./streamUtils";
 
 // Re-export SSHRuntimeConfig from connection pool (defined there to avoid circular deps)
 export type { SSHRuntimeConfig } from "./sshConnectionPool";
@@ -771,78 +759,6 @@ export class SSHRuntime implements Runtime {
     }
   }
 
-  /**
-   * Run .mux/init hook on remote machine if it exists
-   * @param workspacePath - Path to the workspace directory on remote
-   * @param muxEnv - MUX_ environment variables (from getMuxEnv)
-   * @param initLogger - Logger for streaming output
-   * @param abortSignal - Optional abort signal
-   */
-  private async runInitHook(
-    workspacePath: string,
-    muxEnv: Record<string, string>,
-    initLogger: InitLogger,
-    abortSignal?: AbortSignal
-  ): Promise<void> {
-    // Construct hook path - expand tilde if present
-    const remoteHookPath = `${workspacePath}/.mux/init`;
-    initLogger.logStep(`Running init hook: ${remoteHookPath}`);
-
-    // Expand tilde in hook path for execution
-    // Tilde won't be expanded when the path is quoted, so we need to expand it ourselves
-    const hookCommand = expandTildeForSSH(remoteHookPath);
-
-    // Run hook remotely and stream output
-    // No timeout - user init hooks can be arbitrarily long
-    const hookStream = await this.exec(hookCommand, {
-      cwd: workspacePath, // Run in the workspace directory
-      timeout: 3600, // 1 hour - generous timeout for init hooks
-      abortSignal,
-      env: muxEnv,
-    });
-
-    // Create line-buffered loggers
-    const loggers = createLineBufferedLoggers(initLogger);
-
-    // Stream stdout/stderr through line-buffered loggers
-    const stdoutReader = hookStream.stdout.getReader();
-    const stderrReader = hookStream.stderr.getReader();
-    const decoder = new TextDecoder();
-
-    // Read stdout in parallel
-    const readStdout = async () => {
-      try {
-        while (true) {
-          const { done, value } = await stdoutReader.read();
-          if (done) break;
-          loggers.stdout.append(decoder.decode(value, { stream: true }));
-        }
-        loggers.stdout.flush();
-      } finally {
-        stdoutReader.releaseLock();
-      }
-    };
-
-    // Read stderr in parallel
-    const readStderr = async () => {
-      try {
-        while (true) {
-          const { done, value } = await stderrReader.read();
-          if (done) break;
-          loggers.stderr.append(decoder.decode(value, { stream: true }));
-        }
-        loggers.stderr.flush();
-      } finally {
-        stderrReader.releaseLock();
-      }
-    };
-
-    // Wait for completion
-    const [exitCode] = await Promise.all([hookStream.exitCode, readStdout(), readStderr()]);
-
-    initLogger.logComplete(exitCode);
-  }
-
   getWorkspacePath(projectPath: string, workspaceName: string): string {
     const projectName = getProjectName(projectPath);
     return path.posix.join(this.config.srcBaseDir, projectName, workspaceName);
@@ -957,11 +873,13 @@ export class SSHRuntime implements Runtime {
       await this.pullLatestFromOrigin(workspacePath, trunkBranch, initLogger, abortSignal);
 
       // 4. Run .mux/init hook if it exists
-      // Note: runInitHook calls logComplete() internally if hook exists
+      // Note: runInitHookOnRuntime calls logComplete() internally
       const hookExists = await checkInitHookExists(projectPath);
       if (hookExists) {
         const muxEnv = getMuxEnv(projectPath, "ssh", branchName);
-        await this.runInitHook(workspacePath, muxEnv, initLogger, abortSignal);
+        // Expand tilde in hook path (quoted paths don't auto-expand on remote)
+        const hookPath = expandHookPath(`${workspacePath}/.mux/init`);
+        await runInitHookOnRuntime(this, hookPath, workspacePath, muxEnv, initLogger, abortSignal);
       } else {
         // No hook - signal completion immediately
         initLogger.logComplete(0);
@@ -1330,23 +1248,5 @@ export class SSHRuntime implements Runtime {
   }
 }
 
-/**
- * Helper to convert a ReadableStream to a string
- */
-export async function streamToString(stream: ReadableStream<Uint8Array>): Promise<string> {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder("utf-8");
-  let result = "";
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      result += decoder.decode(value, { stream: true });
-    }
-    result += decoder.decode();
-    return result;
-  } finally {
-    reader.releaseLock();
-  }
-}
+// Re-export for backward compatibility with existing imports
+export { streamToString } from "./streamUtils";