Reject tilde paths in SSH runtime srcBaseDir

SSH runtime now requires absolute paths for srcBaseDir to simplify logic and
avoid ambiguity about which user's home directory is being referenced.

Changes:
- SSHRuntime constructor validates srcBaseDir doesn't start with tilde
- Updated default SSH srcBaseDir from ~/cmux to /home/cmux
- Updated all tests to use absolute paths or sshConfig.workdir
- Replaced tilde-handling tests with tilde-rejection tests
- Updated Runtime.ts documentation to clarify path requirements

LocalRuntime continues to expand tilde paths at construction (previous commit),
ensuring all runtime paths are fully resolved at the IPC boundary.

Author: ammar-agent

src/runtime/Runtime.ts

@@ -14,8 +14,8 @@
  *
  * srcBaseDir (base directory for all workspaces):
  *   - Where cmux stores ALL workspace directories
- *   - Local: ~/.cmux/src
- *   - SSH: /home/user/workspace (or custom remote path)
+ *   - Local: ~/.cmux/src (tilde expanded to full path by LocalRuntime)
+ *   - SSH: /home/user/workspace (must be absolute path, no tilde allowed)
  *
  * Workspace Path Computation:
  *   {srcBaseDir}/{projectName}/{workspaceName}
@@ -27,14 +27,14 @@
  *     Example: "feature-123" or "main"
  *
  * Full Example (Local):
- *   srcBaseDir:    ~/.cmux/src
+ *   srcBaseDir:    ~/.cmux/src (expanded to /home/user/.cmux/src)
  *   projectPath:   /Users/me/git/my-project (local git repo)
  *   projectName:   my-project (extracted)
  *   workspaceName: feature-123
- *   → Workspace:   ~/.cmux/src/my-project/feature-123
+ *   → Workspace:   /home/user/.cmux/src/my-project/feature-123
  *
  * Full Example (SSH):
- *   srcBaseDir:    /home/user/workspace
+ *   srcBaseDir:    /home/user/workspace (absolute path required)
  *   projectPath:   /Users/me/git/my-project (local git repo)
  *   projectName:   my-project (extracted)
  *   workspaceName: feature-123

src/runtime/SSHRuntime.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "bun:test";
+import { SSHRuntime } from "./SSHRuntime";
+
+describe("SSHRuntime constructor", () => {
+  it("should reject tilde in srcBaseDir", () => {
+    expect(() => {
+      new SSHRuntime({
+        host: "example.com",
+        srcBaseDir: "~/cmux",
+      });
+    }).toThrow(/cannot start with tilde/);
+  });
+
+  it("should reject bare tilde in srcBaseDir", () => {
+    expect(() => {
+      new SSHRuntime({
+        host: "example.com",
+        srcBaseDir: "~",
+      });
+    }).toThrow(/cannot start with tilde/);
+  });
+
+  it("should accept absolute paths in srcBaseDir", () => {
+    expect(() => {
+      new SSHRuntime({
+        host: "example.com",
+        srcBaseDir: "/home/user/cmux",
+      });
+    }).not.toThrow();
+  });
+});

src/runtime/SSHRuntime.ts

@@ -60,6 +60,15 @@ export class SSHRuntime implements Runtime {
   private readonly controlPath: string;
 
   constructor(config: SSHRuntimeConfig) {
+    // Reject tilde paths - require explicit full paths for SSH
+    // Rationale: Simplifies logic and avoids ambiguity about which user's home directory
+    if (config.srcBaseDir.startsWith("~")) {
+      throw new Error(
+        `SSH runtime srcBaseDir cannot start with tilde. ` +
+          `Use full path (e.g., /home/username/cmux instead of ~/cmux)`
+      );
+    }
+
     this.config = config;
     // Generate unique control path for SSH connection multiplexing
     // This allows multiple SSH sessions to reuse a single TCP connection

src/utils/chatCommands.test.ts

@@ -18,7 +18,7 @@ describe("parseRuntimeString", () => {
     expect(result).toEqual({
       type: "ssh",
       host: "user@host",
-      srcBaseDir: "~/cmux",
+      srcBaseDir: "/home/cmux",
     });
   });
 
@@ -27,7 +27,7 @@ describe("parseRuntimeString", () => {
     expect(result).toEqual({
       type: "ssh",
       host: "User@Host.Example.Com",
-      srcBaseDir: "~/cmux",
+      srcBaseDir: "/home/cmux",
     });
   });
 
@@ -36,7 +36,7 @@ describe("parseRuntimeString", () => {
     expect(result).toEqual({
       type: "ssh",
       host: "user@host",
-      srcBaseDir: "~/cmux",
+      srcBaseDir: "/home/cmux",
     });
   });
 
@@ -50,7 +50,7 @@ describe("parseRuntimeString", () => {
     expect(result).toEqual({
       type: "ssh",
       host: "hostname",
-      srcBaseDir: "~/cmux",
+      srcBaseDir: "/home/cmux",
     });
   });
 
@@ -59,7 +59,7 @@ describe("parseRuntimeString", () => {
     expect(result).toEqual({
       type: "ssh",
       host: "dev.example.com",
-      srcBaseDir: "~/cmux",
+      srcBaseDir: "/home/cmux",
     });
   });
 

src/utils/chatCommands.ts

@@ -56,7 +56,7 @@ export function parseRuntimeString(
     return {
       type: RUNTIME_MODE.SSH,
       host: hostPart,
-      srcBaseDir: "~/cmux", // Default remote base directory (NOT including workspace name)
+      srcBaseDir: "/home/cmux", // Default remote base directory (NOT including workspace name)
     };
   }
 

tests/ipcMain/createWorkspace.test.ts

@@ -590,45 +590,41 @@ exit 1
           );
 
           test.concurrent(
-            "handles tilde (~/) paths correctly (SSH only)",
+            "rejects tilde paths in srcBaseDir (SSH only)",
             async () => {
+              // Skip if SSH server not available
+              if (!sshConfig) {
+                console.log("Skipping SSH-specific test: SSH server not available");
+                return;
+              }
+
               const env = await createTestEnvironment();
               const tempGitRepo = await createTempGitRepo();
 
               try {
-                const branchName = generateBranchName("tilde-test");
+                const branchName = generateBranchName("tilde-rejection-test");
                 const trunkBranch = await detectDefaultTrunkBranch(tempGitRepo);
 
-                // Use ~/workspace/... path instead of absolute path
+                // Try to use tilde path - should be rejected
                 const tildeRuntimeConfig: RuntimeConfig = {
                   type: "ssh",
                   host: `testuser@localhost`,
                   srcBaseDir: `~/workspace`,
-                  identityFile: sshConfig!.privateKeyPath,
-                  port: sshConfig!.port,
+                  identityFile: sshConfig.privateKeyPath,
+                  port: sshConfig.port,
                 };
 
-                const { result, cleanup } = await createWorkspaceWithCleanup(
-                  env,
+                const result = await env.mockIpcRenderer.invoke(
+                  IPC_CHANNELS.WORKSPACE_CREATE,
                   tempGitRepo,
                   branchName,
                   trunkBranch,
                   tildeRuntimeConfig
                 );
 
-                expect(result.success).toBe(true);
-                if (!result.success) {
-                  throw new Error(`Failed to create workspace with tilde path: ${result.error}`);
-                }
-
-                // Wait for init to complete
-                await new Promise((resolve) => setTimeout(resolve, getInitWaitTime()));
-
-                // Verify workspace exists
-                expect(result.metadata.id).toBeDefined();
-                expect(result.metadata.namedWorkspacePath).toBeDefined();
-
-                await cleanup();
+                // Should fail with error about tilde
+                expect(result.success).toBe(false);
+                expect(result.error).toMatch(/cannot start with tilde/i);
               } finally {
                 await cleanupTestEnvironment(env);
                 await cleanupTempGitRepo(tempGitRepo);
@@ -638,74 +634,41 @@ exit 1
           );
 
           test.concurrent(
-            "handles tilde paths with init hooks (SSH only)",
+            "rejects bare tilde in srcBaseDir (SSH only)",
             async () => {
+              // Skip if SSH server not available
+              if (!sshConfig) {
+                console.log("Skipping SSH-specific test: SSH server not available");
+                return;
+              }
+
               const env = await createTestEnvironment();
               const tempGitRepo = await createTempGitRepo();
 
               try {
-                // Add init hook to repo
-                await createInitHook(
-                  tempGitRepo,
-                  `#!/bin/bash
-echo "Init hook executed with tilde path"
-`
-                );
-                await commitChanges(tempGitRepo, "Add init hook for tilde test");
-
-                const branchName = generateBranchName("tilde-init-test");
+                const branchName = generateBranchName("bare-tilde-rejection");
                 const trunkBranch = await detectDefaultTrunkBranch(tempGitRepo);
 
-                // Use ~/workspace/... path instead of absolute path
+                // Try to use bare tilde - should be rejected
                 const tildeRuntimeConfig: RuntimeConfig = {
                   type: "ssh",
                   host: `testuser@localhost`,
-                  srcBaseDir: `~/workspace`,
-                  identityFile: sshConfig!.privateKeyPath,
-                  port: sshConfig!.port,
+                  srcBaseDir: `~`,
+                  identityFile: sshConfig.privateKeyPath,
+                  port: sshConfig.port,
                 };
 
-                // Capture init events to verify hook output
-                const initEvents = setupInitEventCapture(env);
-
-                const { result, cleanup } = await createWorkspaceWithCleanup(
-                  env,
+                const result = await env.mockIpcRenderer.invoke(
+                  IPC_CHANNELS.WORKSPACE_CREATE,
                   tempGitRepo,
                   branchName,
                   trunkBranch,
                   tildeRuntimeConfig
                 );
 
-                expect(result.success).toBe(true);
-                if (!result.success) {
-                  throw new Error(
-                    `Failed to create workspace with tilde path + init hook: ${result.error}`
-                  );
-                }
-
-                // Wait for init to complete (including hook)
-                await new Promise((resolve) => setTimeout(resolve, getInitWaitTime()));
-
-                // Verify init hook was executed
-                const outputEvents = filterEventsByType(initEvents, EVENT_TYPE_INIT_OUTPUT);
-                const outputLines = outputEvents.map((e) => {
-                  const data = e.data as { line?: string };
-                  return data.line ?? "";
-                });
-
-                // Debug: Print all output including errors
-                console.log("=== TILDE INIT HOOK OUTPUT ===");
-                outputEvents.forEach((e) => {
-                  const data = e.data as { line?: string; isError?: boolean };
-                  const prefix = data.isError ? "[ERROR]" : "[INFO] ";
-                  console.log(prefix + (data.line ?? ""));
-                });
-                console.log("=== END TILDE INIT HOOK OUTPUT ===");
-
-                expect(outputLines.some((line) => line.includes("Running init hook"))).toBe(true);
-                expect(outputLines.some((line) => line.includes("Init hook executed"))).toBe(true);
-
-                await cleanup();
+                // Should fail with error about tilde
+                expect(result.success).toBe(false);
+                expect(result.error).toMatch(/cannot start with tilde/i);
               } finally {
                 await cleanupTestEnvironment(env);
                 await cleanupTempGitRepo(tempGitRepo);
@@ -848,7 +811,7 @@ echo "Init hook executed with tilde path"
           const runtimeConfig: RuntimeConfig = {
             type: "ssh",
             host: "testuser@localhost",
-            srcBaseDir: "~/workspace",
+            srcBaseDir: sshConfig.workdir,
             identityFile: sshConfig.privateKeyPath,
             port: sshConfig.port,
           };