Fix redundant CD detection for SSH runtime

- Add runtime-aware path normalization function
- Detect SSH vs Local runtime using instanceof check
- Handle POSIX paths for SSH (no filesystem access needed)
- Handle local paths using Node.js path.resolve
- Add 6 new tests for SSH runtime redundant CD detection
- All 52 bash tool tests pass

Fixes issue where redundant cd commands were not properly detected
when using SSH runtime due to using local path.resolve() on remote paths.

Author: ammar-agent

src/services/tools/bash.test.ts

@@ -1235,3 +1235,139 @@ fi
     expect(remainingProcesses).toBe(0);
   });
 });
+
+describe("SSH runtime redundant cd detection", () => {
+  // Helper to create bash tool with SSH runtime configuration
+  // Note: These tests check redundant cd detection logic only - they don't actually execute via SSH
+  function createTestBashToolWithSSH(cwd: string) {
+    const tempDir = new TestTempDir("test-bash-ssh");
+    const sshRuntime = createRuntime({
+      type: "ssh",
+      host: "test-host",
+      srcBaseDir: "/remote/base",
+    });
+    
+    const tool = createBashTool({
+      cwd,
+      runtime: sshRuntime,
+      tempDir: tempDir.path,
+    });
+
+    return {
+      tool,
+      [Symbol.dispose]() {
+        tempDir[Symbol.dispose]();
+      },
+    };
+  }
+
+  it("should reject redundant cd to absolute path on SSH runtime", async () => {
+    const remoteCwd = "/home/user/project";
+    using testEnv = createTestBashToolWithSSH(remoteCwd);
+    const tool = testEnv.tool;
+
+    const args: BashToolArgs = {
+      script: `cd ${remoteCwd} && echo test`,
+      timeout_secs: 5,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Redundant cd");
+      expect(result.error).toContain("already runs in");
+    }
+  });
+
+  it("should reject redundant cd with relative path (.) on SSH runtime", async () => {
+    const remoteCwd = "/home/user/project";
+    using testEnv = createTestBashToolWithSSH(remoteCwd);
+    const tool = testEnv.tool;
+
+    const args: BashToolArgs = {
+      script: "cd . && echo test",
+      timeout_secs: 5,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Redundant cd");
+    }
+  });
+
+  it("should reject redundant cd with tilde path on SSH runtime", async () => {
+    const remoteCwd = "~/project";
+    using testEnv = createTestBashToolWithSSH(remoteCwd);
+    const tool = testEnv.tool;
+
+    const args: BashToolArgs = {
+      script: "cd ~/project && echo test",
+      timeout_secs: 5,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Redundant cd");
+    }
+  });
+
+  it("should reject redundant cd with single tilde on SSH runtime", async () => {
+    const remoteCwd = "~";
+    using testEnv = createTestBashToolWithSSH(remoteCwd);
+    const tool = testEnv.tool;
+
+    const args: BashToolArgs = {
+      script: "cd ~ && echo test",
+      timeout_secs: 5,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Redundant cd");
+    }
+  });
+
+  it("should handle trailing slashes in path comparison on SSH runtime", async () => {
+    const remoteCwd = "/home/user/project";
+    using testEnv = createTestBashToolWithSSH(remoteCwd);
+    const tool = testEnv.tool;
+
+    const args: BashToolArgs = {
+      script: "cd /home/user/project/ && echo test",
+      timeout_secs: 5,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Redundant cd");
+    }
+  });
+
+  it("should handle cwd with trailing slash on SSH runtime", async () => {
+    const remoteCwd = "/home/user/project/";
+    using testEnv = createTestBashToolWithSSH(remoteCwd);
+    const tool = testEnv.tool;
+
+    const args: BashToolArgs = {
+      script: "cd /home/user/project && echo test",
+      timeout_secs: 5,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Redundant cd");
+    }
+  });
+});
+

src/services/tools/bash.ts

@@ -16,6 +16,70 @@ import { EXIT_CODE_ABORTED, EXIT_CODE_TIMEOUT } from "@/constants/exitCodes";
 import type { BashToolResult } from "@/types/tools";
 import type { ToolConfiguration, ToolFactory } from "@/utils/tools/tools";
 import { TOOL_DEFINITIONS } from "@/utils/tools/toolDefinitions";
+import { SSHRuntime } from "@/runtime/SSHRuntime";
+
+/**
+ * Normalize a path for comparison purposes.
+ * Works for both local and remote (SSH) paths.
+ * Handles:
+ * - Relative paths (. and ..)
+ * - Tilde expansion (~)
+ * - Removes trailing slashes
+ * - Resolves to absolute paths where possible
+ *
+ * For SSH runtime, uses POSIX path semantics (forward slashes).
+ * For local runtime, uses Node.js path.resolve.
+ */
+function normalizePath(targetPath: string, basePath: string, isSSH: boolean): string {
+  // Trim whitespace
+  const target = targetPath.trim();
+  const base = basePath.trim();
+
+  if (isSSH) {
+    // For SSH, we need to handle paths in a POSIX-like manner
+    // without actually accessing the remote filesystem
+    
+    // Handle special case: current directory
+    if (target === ".") {
+      return base;
+    }
+
+    // Handle tilde expansion
+    let normalizedTarget = target;
+    if (target === "~" || target.startsWith("~/")) {
+      // Can't normalize ~ without knowing $HOME, but we can compare
+      // if both use ~ or if base uses ~
+      normalizedTarget = target;
+    } else if (target.startsWith("/")) {
+      // Absolute path - use as-is
+      normalizedTarget = target;
+    } else {
+      // Relative path - resolve against base
+      // Simple POSIX path joining
+      normalizedTarget = base.endsWith("/") ? base + target : base + "/" + target;
+    }
+
+    // Remove trailing slash for comparison (except for root "/")
+    if (normalizedTarget.length > 1 && normalizedTarget.endsWith("/")) {
+      normalizedTarget = normalizedTarget.slice(0, -1);
+    }
+
+    // Handle base path normalization
+    let normalizedBase = base;
+    if (normalizedBase.length > 1 && normalizedBase.endsWith("/")) {
+      normalizedBase = normalizedBase.slice(0, -1);
+    }
+
+    return normalizedTarget;
+  } else {
+    // For local runtime, use Node.js path resolution
+    // Handle special case: current directory
+    if (target === ".") {
+      return path.resolve(base);
+    }
+    return path.resolve(base, target);
+  }
+}
 
 /**
  * Bash execution tool factory for AI assistant
@@ -83,11 +147,12 @@ export const createBashTool: ToolFactory = (config: ToolConfiguration) => {
       const match = cdPattern.exec(script);
       if (match) {
         const targetPath = match[1].trim();
-        // For SSH runtime, config.cwd might use $HOME - need to handle this
-        // Normalize paths for comparison (resolve to absolute where possible)
-        // Note: This check is best-effort - it won't catch all cases on SSH (e.g., ~/path vs $HOME/path)
-        const normalizedTarget = path.resolve(config.cwd, targetPath);
-        const normalizedCwd = path.resolve(config.cwd);
+        // Determine if we're using SSH runtime to apply appropriate path normalization
+        const isSSH = config.runtime instanceof SSHRuntime;
+        
+        // Normalize both paths for comparison using runtime-appropriate logic
+        const normalizedTarget = normalizePath(targetPath, config.cwd, isSSH);
+        const normalizedCwd = isSSH ? config.cwd.replace(/\/$/, "") : path.resolve(config.cwd);
 
         if (normalizedTarget === normalizedCwd) {
           return {