🤖 Refactor SSH sync to avoid shell escaping complexity

Replace complex single-pipeline approach with multiple SSH round trips.

Problem:
- Complex shell escaping with nested quoting (4 backslashes, \\\\\$HOME, etc.)
- Hard to reason about what gets expanded when and where
- Tilde paths like ~/cmux/project failed due to escaping bugs
- User reported: "cd: /root/cmux/r2: No such file or directory"

Solution: Multiple SSH round trips (simpler, no escaping issues)
1. **Create bundle**: Pipe locally to remote via ssh (one level of quoting)
2. **Clone**: Use this.exec() with proper tilde expansion
3. **Remove**: Use this.exec() to clean up bundle file

Benefits:
- Zero complex escaping - each step is simple
- this.exec() handles all tilde expansion consistently
- Easier to debug (can run each step independently)
- More resilient error handling (cleanup on failure)
- User said: "It's ok if we have multiple SSH round trips"

Changes:
- syncProjectToRemote: 3 separate steps instead of one complex pipeline
- Use timestamp instead of $$ for bundle naming (simpler)
- Fixed bare '~' expansion in exec() (was only handling ~/...)
- Bundle path: ~/.cmux-bundle-<timestamp>.bundle

All 14 integration tests passing (6 local + 6 SSH + 2 SSH-specific).
Tilde path test verifies ~/workspace/... works correctly.

_Generated with `cmux`_

Author: ammar-agent

src/runtime/SSHRuntime.ts

@@ -64,7 +64,9 @@ export class SSHRuntime implements Runtime {
 
     // Expand ~/path to $HOME/path before quoting (~ doesn't expand in quotes)
     let cwd = options.cwd;
-    if (cwd.startsWith("~/")) {
+    if (cwd === "~") {
+      cwd = "$HOME";
+    } else if (cwd.startsWith("~/")) {
       cwd = "$HOME/" + cwd.slice(2);
     }
 
@@ -313,56 +315,90 @@ export class SSHRuntime implements Runtime {
    * - Simpler implementation
    */
   private async syncProjectToRemote(projectPath: string, initLogger: InitLogger): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      // Build SSH args
-      const sshArgs = this.buildSSHArgs(true);
-
-      // For paths starting with ~/, expand to $HOME
-      let remoteWorkdir: string;
-      if (this.config.workdir.startsWith("~/")) {
-        const pathWithoutTilde = this.config.workdir.slice(2);
-        remoteWorkdir = `"\\\\$HOME/${pathWithoutTilde}"`; // Escape $ so local shell doesn't expand it
-      } else {
-        remoteWorkdir = JSON.stringify(this.config.workdir);
-      }
+    // Use timestamp-based bundle path to avoid conflicts (simpler than $$)
+    const timestamp = Date.now();
+    const bundleTempPath = `~/.cmux-bundle-${timestamp}.bundle`;
 
-      // Use git bundle to create a packfile of all refs, pipe through ssh for cloning
-      // This creates a real git repository on the remote with full history
-      // Wrap remote commands in bash to avoid issues with non-bash shells (fish, zsh, etc)
-      // Save bundle to temp file on remote, clone from it, then clean up
-      // Use $$ for PID to avoid conflicts, escape $ so it's evaluated on remote
-      const bundleTempPath = `\\$HOME/.cmux-bundle-\\$\\$.bundle`;
-      const command = `cd ${JSON.stringify(projectPath)} && git bundle create - --all | ssh ${sshArgs.join(" ")} "bash -c 'cat > ${bundleTempPath} && git clone --quiet ${bundleTempPath} ${remoteWorkdir} && rm ${bundleTempPath}'"`;
-
-      log.debug(`Starting git bundle+ssh: ${command}`);
-      const proc = spawn("bash", ["-c", command]);
-
-      // Use helper to stream output and prevent buffer overflow
-      streamProcessToLogger(proc, initLogger, {
-        logStdout: false, // bundle stdout is binary, drain silently
-        logStderr: true, // Errors go to init stream
-        command: `git bundle+ssh: ${command}`, // Log the full command
-      });
+    try {
+      // Step 1: Create bundle locally and pipe to remote file via SSH
+      initLogger.logStep(`Creating git bundle...`);
+      await new Promise<void>((resolve, reject) => {
+        const sshArgs = this.buildSSHArgs(true);
+        const command = `cd ${JSON.stringify(projectPath)} && git bundle create - --all | ssh ${sshArgs.join(" ")} "cat > ${bundleTempPath}"`;
+
+        log.debug(`Creating bundle: ${command}`);
+        const proc = spawn("bash", ["-c", command]);
+
+        streamProcessToLogger(proc, initLogger, {
+          logStdout: false,
+          logStderr: true,
+        });
+
+        let stderr = "";
+        proc.stderr.on("data", (data: Buffer) => {
+          stderr += data.toString();
+        });
 
-      let stderr = "";
-      proc.stderr.on("data", (data: Buffer) => {
-        stderr += data.toString();
+        proc.on("close", (code) => {
+          if (code === 0) {
+            resolve();
+          } else {
+            reject(new Error(`Failed to create bundle: ${stderr}`));
+          }
+        });
+
+        proc.on("error", (err) => {
+          reject(err);
+        });
       });
 
-      proc.on("close", (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          reject(new Error(`git bundle+ssh failed with exit code ${code ?? "unknown"}: ${stderr}`));
-        }
+      // Step 2: Clone from bundle on remote using this.exec (handles tilde expansion)
+      initLogger.logStep(`Cloning repository on remote...`);
+      const cloneStream = this.exec(`git clone --quiet ${bundleTempPath} ${JSON.stringify(this.config.workdir)}`, {
+        cwd: "~",
+        timeout: 300, // 5 minutes for clone
       });
 
-      proc.on("error", (err) => {
-        reject(err);
+      const [cloneStdout, cloneStderr, cloneExitCode] = await Promise.all([
+        streamToString(cloneStream.stdout),
+        streamToString(cloneStream.stderr),
+        cloneStream.exitCode,
+      ]);
+
+      if (cloneExitCode !== 0) {
+        throw new Error(`Failed to clone repository: ${cloneStderr || cloneStdout}`);
+      }
+
+      // Step 3: Remove bundle file
+      initLogger.logStep(`Cleaning up bundle file...`);
+      const rmStream = this.exec(`rm ${bundleTempPath}`, {
+        cwd: "~",
+        timeout: 10,
       });
-    });
+
+      const rmExitCode = await rmStream.exitCode;
+      if (rmExitCode !== 0) {
+        log.info(`Failed to remove bundle file ${bundleTempPath}, but continuing`);
+      }
+
+      initLogger.logStep(`Repository cloned successfully`);
+    } catch (error) {
+      // Try to clean up bundle file on error
+      try {
+        const rmStream = this.exec(`rm -f ${bundleTempPath}`, {
+          cwd: "~",
+          timeout: 10,
+        });
+        await rmStream.exitCode;
+      } catch {
+        // Ignore cleanup errors
+      }
+
+      throw error;
+    }
   }
 
+
   /**
    * Run .cmux/init hook on remote machine if it exists
    */