fix: restore Docker container name for existing workspaces

The DockerRuntime now accepts containerName in its config for existing
workspaces. When createRuntime is called with projectPath and workspaceName
options, the container name is derived and passed to DockerRuntime,
allowing exec operations to work without calling createWorkspace first.

- Added containerName to DockerRuntimeConfig (optional)
- Added workspaceName to CreateRuntimeOptions
- Updated all createRuntime call sites to pass workspaceName
- Added tests for getContainerName and containerName config

Author: ammar-agent

src/node/runtime/DockerRuntime.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "bun:test";
-import { DockerRuntime } from "./DockerRuntime";
+import { DockerRuntime, getContainerName } from "./DockerRuntime";
 
 /**
  * DockerRuntime constructor tests (run with bun test)
@@ -29,4 +29,35 @@ describe("DockerRuntime constructor", () => {
     const runtime = new DockerRuntime({ image: "ubuntu:22.04" });
     expect(runtime.getWorkspacePath("/any/project", "any-branch")).toBe("/src");
   });
+
+  it("should accept containerName for existing workspaces", () => {
+    // When recreating runtime for existing workspace, containerName is passed in config
+    const runtime = new DockerRuntime({
+      image: "ubuntu:22.04",
+      containerName: "mux-myproject-my-feature",
+    });
+    expect(runtime.getImage()).toBe("ubuntu:22.04");
+    // Runtime should be ready for exec operations without calling createWorkspace
+  });
+});
+
+describe("getContainerName", () => {
+  it("should generate container name from project and workspace", () => {
+    expect(getContainerName("/home/user/myproject", "feature-branch")).toBe(
+      "mux-myproject-feature-branch"
+    );
+  });
+
+  it("should sanitize special characters", () => {
+    expect(getContainerName("/home/user/my@project", "feature/branch")).toBe(
+      "mux-my-project-feature-branch"
+    );
+  });
+
+  it("should handle long names", () => {
+    const longName = "a".repeat(100);
+    const result = getContainerName("/project", longName);
+    // Docker has 64 char limit, function uses 63 to be safe
+    expect(result.length).toBeLessThanOrEqual(63);
+  });
 });

src/node/runtime/DockerRuntime.ts

@@ -103,6 +103,13 @@ function runDockerCommand(command: string, timeoutMs = 30000): Promise<DockerCom
 export interface DockerRuntimeConfig {
   /** Docker image to use (e.g., ubuntu:22.04) */
   image: string;
+  /**
+   * Container name for existing workspaces.
+   * When creating a new workspace, this is computed during createWorkspace().
+   * When recreating runtime for an existing workspace, this should be passed
+   * to allow exec operations without calling createWorkspace again.
+   */
+  containerName?: string;
 }
 
 /**
@@ -121,7 +128,7 @@ function sanitizeContainerName(name: string): string {
  * Generate container name from project path and workspace name.
  * Format: mux-{projectName}-{workspaceName}
  */
-function getContainerName(projectPath: string, workspaceName: string): string {
+export function getContainerName(projectPath: string, workspaceName: string): string {
   const projectName = getProjectName(projectPath);
   return sanitizeContainerName(`mux-${projectName}-${workspaceName}`);
 }
@@ -131,9 +138,15 @@ function getContainerName(projectPath: string, workspaceName: string): string {
  */
 export class DockerRuntime implements Runtime {
   private readonly config: DockerRuntimeConfig;
+  /** Container name - set during construction (for existing) or createWorkspace (for new) */
+  private containerName?: string;
 
   constructor(config: DockerRuntimeConfig) {
     this.config = config;
+    // If container name is provided (existing workspace), store it
+    if (config.containerName) {
+      this.containerName = config.containerName;
+    }
   }
 
   /**
@@ -154,16 +167,17 @@ export class DockerRuntime implements Runtime {
       throw new RuntimeError("Operation aborted before execution", "exec");
     }
 
-    // Extract container name from cwd (assumes cwd is /src for workspace operations)
-    // For Docker, we need the container name which we get from the workspace context
-    // The container name is stored on the runtime instance during workspace creation
-    const containerName = (this as DockerRuntimeWithContainer).containerName;
-    if (!containerName) {
+    // Verify container name is available (set in constructor for existing workspaces,
+    // or set in createWorkspace for new workspaces)
+    if (!this.containerName) {
       throw new RuntimeError(
-        "Docker runtime not initialized with container name. Use createWorkspace first.",
+        "Docker runtime not initialized with container name. " +
+          "For existing workspaces, pass containerName in config. " +
+          "For new workspaces, call createWorkspace first.",
         "exec"
       );
     }
+    const containerName = this.containerName;
 
     // Build command parts
     const parts: string[] = [];
@@ -474,7 +488,7 @@ export class DockerRuntime implements Runtime {
       }
 
       // Store container name on runtime instance for exec operations
-      (this as DockerRuntimeWithContainer).containerName = containerName;
+      this.containerName = containerName;
 
       initLogger.logStep("Container created successfully");
 
@@ -494,13 +508,13 @@ export class DockerRuntime implements Runtime {
     const { projectPath, branchName, trunkBranch, workspacePath, initLogger, abortSignal } = params;
 
     try {
-      const containerName = (this as DockerRuntimeWithContainer).containerName;
-      if (!containerName) {
+      if (!this.containerName) {
         return {
           success: false,
           error: "Container not initialized. Call createWorkspace first.",
         };
       }
+      const containerName = this.containerName;
 
       // 1. Sync project to container using git bundle + docker cp
       initLogger.logStep("Syncing project files to container...");
@@ -863,14 +877,6 @@ export class DockerRuntime implements Runtime {
     return Promise.resolve("/tmp");
   }
 }
-
-/**
- * Extended interface for runtime with container name set
- */
-interface DockerRuntimeWithContainer extends DockerRuntime {
-  containerName?: string;
-}
-
 /**
  * Helper to convert a ReadableStream to a string
  */

src/node/runtime/runtimeFactory.ts

@@ -4,7 +4,7 @@ import type { Runtime, RuntimeAvailability } from "./Runtime";
 import { LocalRuntime } from "./LocalRuntime";
 import { WorktreeRuntime } from "./WorktreeRuntime";
 import { SSHRuntime } from "./SSHRuntime";
-import { DockerRuntime } from "./DockerRuntime";
+import { DockerRuntime, getContainerName } from "./DockerRuntime";
 import type { RuntimeConfig, RuntimeMode } from "@/common/types/runtime";
 import { hasSrcBaseDir } from "@/common/types/runtime";
 import { isIncompatibleRuntimeConfig } from "@/common/utils/runtimeCompatibility";
@@ -30,9 +30,15 @@ export class IncompatibleRuntimeError extends Error {
 export interface CreateRuntimeOptions {
   /**
    * Project path - required for project-dir local runtimes (type: "local" without srcBaseDir).
+   * For Docker runtimes with existing workspaces, used together with workspaceName to derive container name.
    * For other runtime types, this is optional and used only for getWorkspacePath calculations.
    */
   projectPath?: string;
+  /**
+   * Workspace name - required for Docker runtimes when connecting to an existing workspace.
+   * Used together with projectPath to derive the container name.
+   */
+  workspaceName?: string;
 }
 
 /**
@@ -82,10 +88,17 @@ export function createRuntime(config: RuntimeConfig, options?: CreateRuntimeOpti
         port: config.port,
       });
 
-    case "docker":
+    case "docker": {
+      // For existing workspaces, derive container name from project+workspace
+      const containerName =
+        options?.projectPath && options?.workspaceName
+          ? getContainerName(options.projectPath, options.workspaceName)
+          : undefined;
       return new DockerRuntime({
         image: config.image,
+        containerName,
       });
+    }
 
     default: {
       const unknownConfig = config as { type?: string };

src/node/services/agentSession.ts

@@ -269,7 +269,7 @@ export class AgentSession {
         : (() => {
             const runtime = createRuntime(
               metadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-              { projectPath: metadata.projectPath }
+              { projectPath: metadata.projectPath, workspaceName: metadata.name }
             );
             return runtime.getWorkspacePath(metadata.projectPath, metadata.name);
           })();

src/node/services/aiService.ts

@@ -975,7 +975,7 @@ export class AIService extends EventEmitter {
       // Get workspace path - handle both worktree and in-place modes
       const runtime = createRuntime(
         metadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-        { projectPath: metadata.projectPath }
+        { projectPath: metadata.projectPath, workspaceName: metadata.name }
       );
       // In-place workspaces (CLI/benchmarks) have projectPath === name
       // Use path directly instead of reconstructing via getWorkspacePath

src/node/services/terminalService.ts

@@ -66,9 +66,10 @@ export class TerminalService {
         throw new Error(`Workspace not found: ${params.workspaceId}`);
       }
 
-      // 2. Create runtime
+      // 2. Create runtime (pass workspace info for Docker container name derivation)
       const runtime = createRuntime(
-        workspaceMetadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir }
+        workspaceMetadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
+        { projectPath: workspaceMetadata.projectPath, workspaceName: workspaceMetadata.name }
       );
 
       // 3. Compute workspace path

src/node/services/workspaceService.ts

@@ -428,7 +428,7 @@ export class WorkspaceService extends EventEmitter {
 
         const runtime = createRuntime(
           metadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-          { projectPath }
+          { projectPath, workspaceName: metadata.name }
         );
 
         // Delete workspace from runtime
@@ -539,7 +539,7 @@ export class WorkspaceService extends EventEmitter {
 
       const runtime = createRuntime(
         oldMetadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-        { projectPath }
+        { projectPath, workspaceName: oldName }
       );
 
       const renameResult = await runtime.renameWorkspace(projectPath, oldName, newName);
@@ -656,7 +656,10 @@ export class WorkspaceService extends EventEmitter {
         type: "local",
         srcBaseDir: this.config.srcDir,
       };
-      const runtime = createRuntime(sourceRuntimeConfig);
+      const runtime = createRuntime(sourceRuntimeConfig, {
+        projectPath: foundProjectPath,
+        workspaceName: sourceMetadata.name,
+      });
 
       const newWorkspaceId = this.config.generateStableId();
 
@@ -1039,7 +1042,10 @@ export class WorkspaceService extends EventEmitter {
         type: "local" as const,
         srcBaseDir: this.config.srcDir,
       };
-      const runtime = createRuntime(runtimeConfig, { projectPath: metadata.projectPath });
+      const runtime = createRuntime(runtimeConfig, {
+        projectPath: metadata.projectPath,
+        workspaceName: metadata.name,
+      });
       const workspacePath = runtime.getWorkspacePath(metadata.projectPath, metadata.name);
 
       // Create bash tool