🤖 fix: use stdin.abort() to prevent hangs on SSH commands (#504)

## Problem

Commands like `cat /tmp/results.json | jq '.'` would sometimes hang
forever over SSH, not respecting timeouts. This was observed over SSH
with the bash tool, and it's unclear if it happens on local workspaces.

## Root Cause

The issue stems from using `WritableStream.close()` to close stdin:

- **`close()` is async** and waits for graceful acknowledgment from the
remote end
- Over SSH with ControlMaster multiplexing, the SSH channel's stdin
buffer might not be immediately flushed
- The `close()` promise waits for acknowledgment that may never come
- Even timeouts couldn't help because the promise was already stuck in
Node.js stream machinery

## Solution

**Use `stdin.abort()` instead of `stdin.close()` for immediate
closure:**

- **`abort()`** - Immediate, synchronous force-close. Marks stream as
errored, releases locks, doesn't wait
- **`close()`** - Graceful, async close. Waits for all writes to be
acknowledged

Applied selectively:
- **bash tool**: Use `abort()` - commands don't need stdin at all
- **SSHRuntime mv/rm/stat**: Use `abort()` - commands don't read stdin
- **SSHRuntime writeFile**: Keep `close()` - needs to flush data written
to stdin

## Testing

- All 45 bash tool tests pass
- SSH integration tests pass:
  - `runtimeExecuteBash` - verifies bash commands over SSH work
  - `renameWorkspace` - verifies mv operations work
- `runtimeFileEditing` - verifies file writes (which use stdin) work
correctly
- All 921 unit tests pass
- Typecheck passes

## Implementation Details

Changed 4 locations:
1. `src/services/tools/bash.ts` - Use `abort()` to close stdin
immediately
2. `src/runtime/SSHRuntime.ts` (3 places) - Use `abort()` for mv/rm/stat
commands

Kept `close()` in 1 location:
- `SSHRuntime.writeFile()` - Needs graceful close to ensure all data is
written

---
_Generated with `cmux`_

Author: ammar-agent

src/runtime/SSHRuntime.ts

@@ -929,7 +929,8 @@ export class SSHRuntime implements Runtime {
         abortSignal,
       });
 
-      await stream.stdin.close();
+      // Command doesn't use stdin - abort to close immediately without waiting
+      await stream.stdin.abort();
       const exitCode = await stream.exitCode;
 
       if (exitCode !== 0) {
@@ -999,7 +1000,8 @@ export class SSHRuntime implements Runtime {
         abortSignal,
       });
 
-      await checkStream.stdin.close();
+      // Command doesn't use stdin - abort to close immediately without waiting
+      await checkStream.stdin.abort();
       const checkExitCode = await checkStream.exitCode;
 
       // Handle check results
@@ -1072,7 +1074,8 @@ export class SSHRuntime implements Runtime {
         abortSignal,
       });
 
-      await stream.stdin.close();
+      // Command doesn't use stdin - abort to close immediately without waiting
+      await stream.stdin.abort();
       const exitCode = await stream.exitCode;
 
       if (exitCode !== 0) {

src/services/tools/bash.test.ts

@@ -637,7 +637,8 @@ describe("bash tool", () => {
     const startTime = performance.now();
 
     // cat without input should complete immediately
-    // This used to hang because cat would wait for stdin
+    // This used to hang because stdin.close() would wait for acknowledgment
+    // Fixed by using stdin.abort() for immediate closure
     const args: BashToolArgs = {
       script: "echo test | cat",
       timeout_secs: 5,

src/services/tools/bash.ts

@@ -147,9 +147,11 @@ export const createBashTool: ToolFactory = (config: ToolConfiguration) => {
           abortSignal.addEventListener("abort", abortListener);
         }
 
-        // Close stdin immediately - we don't need to send any input
-        // This is critical: not closing stdin can cause the runtime to wait forever
-        execStream.stdin.close().catch(() => {
+        // Force-close stdin immediately - we don't need to send any input
+        // Use abort() instead of close() for immediate, synchronous closure
+        // close() is async and waits for acknowledgment, which can hang over SSH
+        // abort() immediately marks stream as errored and releases locks
+        execStream.stdin.abort().catch(() => {
           // Ignore errors - stream might already be closed
         });
 

tests/ipcMain/runtimeExecuteBash.test.ts

@@ -266,6 +266,83 @@ describeIntegration("Runtime Bash Execution", () => {
         },
         type === "ssh" ? TEST_TIMEOUT_SSH_MS : TEST_TIMEOUT_LOCAL_MS
       );
+
+      test.concurrent(
+        "should not hang on commands that read stdin without input",
+        async () => {
+          const env = await createTestEnvironment();
+          const tempGitRepo = await createTempGitRepo();
+
+          try {
+            // Setup provider
+            await setupProviders(env.mockIpcRenderer, {
+              anthropic: {
+                apiKey: getApiKey("ANTHROPIC_API_KEY"),
+              },
+            });
+
+            // Create workspace
+            const branchName = generateBranchName("bash-stdin");
+            const runtimeConfig = getRuntimeConfig(branchName);
+            const { workspaceId, cleanup } = await createWorkspaceWithInit(
+              env,
+              tempGitRepo,
+              branchName,
+              runtimeConfig,
+              true, // waitForInit
+              type === "ssh"
+            );
+
+            try {
+              // Create a test file with JSON content
+              await sendMessageAndWait(
+                env,
+                workspaceId,
+                'Run bash: echo \'{"test": "data"}\' > /tmp/test.json',
+                HAIKU_MODEL,
+                BASH_ONLY
+              );
+
+              // Test command that pipes file through stdin-reading command (jq)
+              // This would hang forever if stdin.close() was used instead of stdin.abort()
+              // Regression test for: https://github.com/coder/cmux/issues/503
+              const startTime = Date.now();
+              const events = await sendMessageAndWait(
+                env,
+                workspaceId,
+                "Run bash with 3s timeout: cat /tmp/test.json | jq '.'",
+                HAIKU_MODEL,
+                BASH_ONLY,
+                15000 // 15s max wait - should complete in < 5s
+              );
+              const duration = Date.now() - startTime;
+
+              // Extract response text
+              const responseText = extractTextFromEvents(events);
+
+              // Verify command completed successfully (not timeout)
+              expect(responseText).toContain("test");
+              expect(responseText).toContain("data");
+
+              // Verify command completed quickly (not hanging until timeout)
+              // Should complete in under 5 seconds for SSH, 3 seconds for local
+              const maxDuration = type === "ssh" ? 8000 : 5000;
+              expect(duration).toBeLessThan(maxDuration);
+
+              // Verify bash tool was called
+              const toolCallStarts = events.filter((e: any) => e.type === "tool-call-start");
+              const bashCalls = toolCallStarts.filter((e: any) => e.toolName === "bash");
+              expect(bashCalls.length).toBeGreaterThan(0);
+            } finally {
+              await cleanup();
+            }
+          } finally {
+            await cleanupTempGitRepo(tempGitRepo);
+            await cleanupTestEnvironment(env);
+          }
+        },
+        type === "ssh" ? TEST_TIMEOUT_SSH_MS : TEST_TIMEOUT_LOCAL_MS
+      );
     }
   );
 });