🤖 Fix resolvePath() to separate path resolution from existence checking

- Remove existence checking from LocalRuntime.resolvePath()
  - Now just expands tildes and resolves to absolute path
  - No longer uses fsPromises.access() to verify path exists
- Update SSHRuntime.resolvePath() to use readlink -m instead of realpath
  - readlink -m normalizes paths without requiring them to exist
  - Properly separates path resolution from validation
- Extract SSH command spawning pattern into execSSHCommand() helper
  - Reduces duplication in SSHRuntime
  - Reusable for simple SSH commands that return stdout
- Remove SSH integration tests for resolvePath()
  - Will rely on createWorkspace matrix tests for end-to-end verification
  - Keep only constructor unit tests that don't require SSH
- Update LocalRuntime test to expect non-existent paths to resolve successfully
- Revert unrelated gitService.test.ts debug logging

This improves separation of concerns: resolvePath() now purely resolves paths
without side effects, allowing callers to decide whether to validate existence.

Generated with `cmux`

Author: ammar-agent

src/runtime/LocalRuntime.test.ts

@@ -51,12 +51,11 @@ describe("LocalRuntime.resolvePath", () => {
     expect(resolved).toBe("/tmp");
   });
 
-  it("should reject non-existent paths", async () => {
+  it("should resolve non-existent paths without checking existence", async () => {
     const runtime = new LocalRuntime("/tmp");
-    // eslint-disable-next-line @typescript-eslint/await-thenable
-    await expect(runtime.resolvePath("/this/path/does/not/exist/12345")).rejects.toThrow(
-      /Cannot resolve path/
-    );
+    const resolved = await runtime.resolvePath("/this/path/does/not/exist/12345");
+    // Should resolve to absolute path without checking if it exists
+    expect(resolved).toBe("/this/path/does/not/exist/12345");
   });
 
   it("should resolve relative paths from cwd", async () => {

src/runtime/LocalRuntime.ts

@@ -306,19 +306,7 @@ export class LocalRuntime implements Runtime {
     const expanded = expandTilde(filePath);
 
     // Resolve to absolute path (handles relative paths like "./foo")
-    const resolved = path.resolve(expanded);
-
-    // Verify path exists
-    try {
-      await fsPromises.access(resolved);
-      return resolved;
-    } catch (err) {
-      throw new RuntimeErrorClass(
-        `Cannot resolve path '${filePath}': ${getErrorMessage(err)}`,
-        "file_io",
-        err instanceof Error ? err : undefined
-      );
-    }
+    return path.resolve(expanded);
   }
 
   normalizePath(targetPath: string, basePath: string): string {

src/runtime/SSHRuntime.test.ts

@@ -31,63 +31,3 @@ describe("SSHRuntime constructor", () => {
     }).not.toThrow();
   });
 });
-
-describe("SSHRuntime.resolvePath", () => {
-  // Note: These tests require TEST_INTEGRATION=1 to run with actual SSH connection
-  const isIntegrationTest = process.env.TEST_INTEGRATION === "1";
-  const describeIfIntegration = isIntegrationTest ? describe : describe.skip;
-
-  describeIfIntegration("with SSH connection", () => {
-    it("should expand tilde to home directory", async () => {
-      const runtime = new SSHRuntime({
-        host: process.env.SSH_HOST ?? "localhost",
-        port: parseInt(process.env.SSH_PORT ?? "2222"),
-        identityFile: process.env.SSH_IDENTITY_FILE,
-        srcBaseDir: "~/test-workspace",
-      });
-
-      const resolved = await runtime.resolvePath("~");
-      // Should be an absolute path
-      expect(resolved).toMatch(/^\/home\//);
-    });
-
-    it("should expand tilde with path", async () => {
-      const runtime = new SSHRuntime({
-        host: process.env.SSH_HOST ?? "localhost",
-        port: parseInt(process.env.SSH_PORT ?? "2222"),
-        identityFile: process.env.SSH_IDENTITY_FILE,
-        srcBaseDir: "~/test-workspace",
-      });
-
-      const resolved = await runtime.resolvePath("~/..");
-      // Should be parent of home directory
-      expect(resolved).toBe("/home");
-    });
-
-    it("should resolve absolute paths", async () => {
-      const runtime = new SSHRuntime({
-        host: process.env.SSH_HOST ?? "localhost",
-        port: parseInt(process.env.SSH_PORT ?? "2222"),
-        identityFile: process.env.SSH_IDENTITY_FILE,
-        srcBaseDir: "/tmp",
-      });
-
-      const resolved = await runtime.resolvePath("/tmp");
-      expect(resolved).toBe("/tmp");
-    });
-
-    it("should reject non-existent paths", async () => {
-      const runtime = new SSHRuntime({
-        host: process.env.SSH_HOST ?? "localhost",
-        port: parseInt(process.env.SSH_PORT ?? "2222"),
-        identityFile: process.env.SSH_IDENTITY_FILE,
-        srcBaseDir: "/tmp",
-      });
-
-      // eslint-disable-next-line @typescript-eslint/await-thenable
-      await expect(runtime.resolvePath("/this/path/does/not/exist/12345")).rejects.toThrow(
-        /Failed to resolve path/
-      );
-    });
-  });
-});

src/runtime/SSHRuntime.ts

@@ -318,10 +318,18 @@ export class SSHRuntime implements Runtime {
     };
   }
   async resolvePath(filePath: string): Promise<string> {
-    // Use shell to expand tildes and resolve path on remote system
-    // We use `realpath` which resolves symlinks and gives canonical path
-    // Note: realpath also verifies the path exists
-    const command = `realpath ${shescape.quote(filePath)}`;
+    // Use shell to expand tildes and normalize path on remote system
+    // Uses bash to expand ~ and readlink -m to normalize without checking existence
+    // readlink -m canonicalizes the path (handles .., ., //) without requiring it to exist
+    const command = `bash -c 'readlink -m ${shescape.quote(filePath)}'`;
+    return this.execSSHCommand(command);
+  }
+
+  /**
+   * Execute a simple SSH command and return stdout
+   * @private
+   */
+  private async execSSHCommand(command: string): Promise<string> {
     const sshArgs = this.buildSSHArgs();
     sshArgs.push(this.config.host, command);
 
@@ -340,33 +348,18 @@ export class SSHRuntime implements Runtime {
 
       proc.on("close", (code) => {
         if (code !== 0) {
-          reject(
-            new RuntimeErrorClass(
-              `Failed to resolve path '${filePath}' on remote host: ${stderr.trim()}`,
-              "file_io"
-            )
-          );
-          return;
-        }
-
-        const resolved = stdout.trim();
-        if (!resolved?.startsWith("/")) {
-          reject(
-            new RuntimeErrorClass(
-              `Invalid resolved path '${resolved}' for '${filePath}' (expected absolute path)`,
-              "file_io"
-            )
-          );
+          reject(new RuntimeErrorClass(`SSH command failed: ${stderr.trim()}`, "network"));
           return;
         }
 
-        resolve(resolved);
+        const output = stdout.trim();
+        resolve(output);
       });
 
       proc.on("error", (err) => {
         reject(
           new RuntimeErrorClass(
-            `Cannot resolve path '${filePath}' on remote host: ${getErrorMessage(err)}`,
+            `Cannot execute SSH command: ${getErrorMessage(err)}`,
             "network",
             err instanceof Error ? err : undefined
           )

src/services/gitService.test.ts

@@ -55,9 +55,6 @@ describe("removeWorktreeSafe", () => {
     const result = await createWorktree(mockConfig, repoPath, "test-branch", {
       trunkBranch: defaultBranch,
     });
-    if (!result.success) {
-      console.error("createWorktree failed:", result.error);
-    }
     expect(result.success).toBe(true);
     const worktreePath = result.path!;
 
@@ -91,9 +88,6 @@ describe("removeWorktreeSafe", () => {
     const result = await createWorktree(mockConfig, repoPath, "dirty-branch", {
       trunkBranch: defaultBranch,
     });
-    if (!result.success) {
-      console.error("createWorktree failed:", result.error);
-    }
     expect(result.success).toBe(true);
     const worktreePath = result.path!;