🤖 feat: Save overflow output to temp file in bash tool

When bash tool output exceeds max_lines limit, instead of discarding
all output, save it to a temporary file and include the path in the
truncated output. This prevents expensive commands from needing to be
re-run just to see their full output.

Changes:
- Collect all output lines even after truncation is triggered
- Write full output to /tmp/bash-overflow-<timestamp>.txt
- Include file path in truncation marker
- Update tests to verify overflow file creation and cleanup

_Generated with `cmux`_

Author: ammar-agent

src/services/tools/bash.test.ts

@@ -60,12 +60,54 @@ describe("bash tool", () => {
     expect(result.success).toBe(true);
     if (result.success) {
       const lines = result.output.split("\n");
-      // Should have 5 lines plus the truncation marker on the last line
-      expect(lines.length).toBe(5);
-      expect(result.output).toContain("[TRUNCATED]");
+      // Should have 5 lines plus the truncation marker line
+      expect(lines.length).toBe(6); // 5 lines + truncation marker
+      expect(result.output).toContain("[TRUNCATED");
       expect(result.truncated).toBe(true);
     }
   });
+
+  it("should save overflow output to temp file when truncated", async () => {
+    const tool = createBashTool({ cwd: process.cwd() });
+    const args: BashToolArgs = {
+      script: "for i in {1..10}; do echo line$i; done",
+      timeout_secs: 5,
+      max_lines: 5,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      // Output should contain truncation marker with file path
+      expect(result.output).toContain("[TRUNCATED - Full output");
+      expect(result.output).toContain("lines) saved to:");
+      expect(result.output).toContain("bash-overflow-");
+      expect(result.truncated).toBe(true);
+
+      // Extract file path from output
+      const match = result.output.match(/saved to: (.+)\]/);
+      expect(match).toBeDefined();
+      if (match) {
+        const overflowPath = match[1];
+        // Verify file exists
+        const fs = require("fs");
+        expect(fs.existsSync(overflowPath)).toBe(true);
+        
+        // Verify file contains all 10 lines
+        const fileContent = fs.readFileSync(overflowPath, "utf-8");
+        const fileLines = fileContent.split("\n").filter((l: string) => l.length > 0);
+        expect(fileLines.length).toBe(10);
+        expect(fileContent).toContain("line1");
+        expect(fileContent).toContain("line10");
+        
+        // Clean up temp file
+        fs.unlinkSync(overflowPath);
+      }
+    }
+  });
+
+
   it("should clamp max_lines requests above the hard cap", async () => {
     const tool = createBashTool({ cwd: process.cwd() });
     const args: BashToolArgs = {
@@ -80,8 +122,8 @@ describe("bash tool", () => {
     if (result.success) {
       expect(result.truncated).toBe(true);
       const lines = result.output.split("\n");
-      expect(lines).toHaveLength(BASH_HARD_MAX_LINES);
-      expect(result.output).toContain("[TRUNCATED]");
+      expect(lines).toHaveLength(BASH_HARD_MAX_LINES + 1); // +1 for truncation marker
+      expect(result.output).toContain("[TRUNCATED");
     }
   });
 
@@ -102,7 +144,7 @@ describe("bash tool", () => {
     expect(result.success).toBe(true);
     if (result.success) {
       expect(result.truncated).toBe(true);
-      expect(result.output).toContain("[TRUNCATED]");
+      expect(result.output).toContain("[TRUNCATED");
       // Should complete much faster than 10 seconds (give it 2 seconds buffer)
       expect(duration).toBeLessThan(2000);
     }

src/services/tools/bash.ts

@@ -3,6 +3,8 @@ import { spawn } from "child_process";
 import type { ChildProcess } from "child_process";
 import { createInterface } from "readline";
 import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
 import { BASH_DEFAULT_MAX_LINES, BASH_HARD_MAX_LINES } from "@/constants/toolLimits";
 
 import type { BashToolResult } from "@/types/tools";
@@ -131,10 +133,10 @@ export const createBashTool: ToolFactory = (config: ToolConfiguration) => {
         const stderrReader = createInterface({ input: childProcess.child.stderr! });
 
         stdoutReader.on("line", (line) => {
-          if (!truncated && !resolved) {
+          if (!resolved) {
             lines.push(line);
             // Check if we've exceeded the effective max_lines limit
-            if (lines.length >= effectiveMaxLines) {
+            if (!truncated && lines.length >= effectiveMaxLines) {
               truncated = true;
               // Close readline interfaces before killing to ensure clean shutdown
               stdoutReader.close();
@@ -145,10 +147,10 @@ export const createBashTool: ToolFactory = (config: ToolConfiguration) => {
         });
 
         stderrReader.on("line", (line) => {
-          if (!truncated && !resolved) {
+          if (!resolved) {
             lines.push(line);
             // Check if we've exceeded the effective max_lines limit
-            if (lines.length >= effectiveMaxLines) {
+            if (!truncated && lines.length >= effectiveMaxLines) {
               truncated = true;
               // Close readline interfaces before killing to ensure clean shutdown
               stdoutReader.close();
@@ -218,10 +220,26 @@ export const createBashTool: ToolFactory = (config: ToolConfiguration) => {
           stdoutReader.close();
           stderrReader.close();
 
-          // Join lines and add truncation marker if needed
+          // Join lines and handle truncation
           let output = lines.join("\n");
-          if (truncated && output.length > 0) {
-            output += " [TRUNCATED]";
+          let overflowPath: string | undefined;
+          
+          if (truncated && lines.length > 0) {
+            // Write full output to temp file
+            try {
+              const tmpDir = os.tmpdir();
+              const timestamp = Date.now();
+              overflowPath = path.join(tmpDir, `bash-overflow-${timestamp}.txt`);
+              fs.writeFileSync(overflowPath, output, "utf-8");
+              
+              // Truncate output to max_lines and add marker with file path
+              output = lines.slice(0, effectiveMaxLines).join("\n");
+              output += `\n[TRUNCATED - Full output (${lines.length} lines) saved to: ${overflowPath}]`;
+            } catch (err) {
+              // If temp file creation fails, fall back to simple truncation
+              output = lines.slice(0, effectiveMaxLines).join("\n");
+              output += ` [TRUNCATED - ${lines.length} lines]`;
+            }
           }
 
           // Check if this was aborted (stream cancelled)