🤖 feat: Save bash overflow to temp file with short IDs

ammar-agent · ammar-agent · commit 4cff873d015b · 2025-10-08T14:59:30.000-05:00
When bash tool output exceeds limits (100 lines, 16KB, or 1KB/line), save the
full output to a temp file instead of failing with no output. This prevents
expensive commands from needing to be re-run.

Key design decisions:
- NO output shown when truncated - avoids overwhelming context
- Short 8-char hex file IDs (bash-a1b2c3d4.txt) for easy recall
- Helpful filtering examples (grep, head, tail, sed)
- Reminder to clean up temp file when done
- Reduce max_lines to 100 (from 1000) to trigger overflow more reasonably

Changes:
- Continue collecting lines even after truncation triggered
- Write full output to /tmp/bash-&lt;8hex&gt;.txt on overflow
- Return error with file path and filtering instructions
- Update tests to verify overflow file creation and format
- Reduce BASH_DEFAULT_MAX_LINES and BASH_HARD_MAX_LINES to 100

_Generated with `cmux`_
diff --git a/src/constants/toolLimits.ts b/src/constants/toolLimits.ts
@@ -1,4 +1,4 @@
-export const BASH_DEFAULT_MAX_LINES = 1000;
-export const BASH_HARD_MAX_LINES = 1000;
+export const BASH_DEFAULT_MAX_LINES = 100;
+export const BASH_HARD_MAX_LINES = 100;
 export const BASH_MAX_LINE_BYTES = 1024; // 1KB per line
 export const BASH_MAX_TOTAL_BYTES = 16 * 1024; // 16KB total output
diff --git a/src/services/tools/bash.test.ts b/src/services/tools/bash.test.ts
@@ -62,6 +62,58 @@ describe("bash tool", () => {
     }
   });
 
+  it("should save overflow output to temp file with short ID", async () => {
+    const tool = createBashTool({ cwd: process.cwd() });
+    const args: BashToolArgs = {
+      script: "for i in {1..150}; do echo line$i; done",
+      timeout_secs: 5,
+      max_lines: 100,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("[OUTPUT OVERFLOW");
+      expect(result.error).toContain("lines saved to");
+      expect(result.error).toContain("bash-");
+      expect(result.error).toContain(".txt");
+      
+      // Verify helpful filtering instructions are included
+      expect(result.error).toContain("grep '<pattern>'");
+      expect(result.error).toContain("head -n 100");
+      expect(result.error).toContain("tail -n 100");
+      expect(result.error).toContain("When done, clean up: rm");
+
+      // Extract file path from error message
+      const match = result.error.match(/saved to (\/[^\]]+\.txt)/);
+      expect(match).toBeDefined();
+      if (match) {
+        const overflowPath = match[1];
+        
+        // Verify file has short ID format (bash-<8 hex chars>.txt)
+        const filename = overflowPath.split("/").pop();
+        expect(filename).toMatch(/^bash-[0-9a-f]{8}\.txt$/);
+        
+        // Verify file exists
+        const fs = require("fs");
+        expect(fs.existsSync(overflowPath)).toBe(true);
+        
+        // Verify file contains collected lines (at least 100, may be slightly more)
+        const fileContent = fs.readFileSync(overflowPath, "utf-8");
+        const fileLines = fileContent.split("\n").filter((l: string) => l.length > 0);
+        expect(fileLines.length).toBeGreaterThanOrEqual(100);
+        expect(fileContent).toContain("line1");
+        expect(fileContent).toContain("line100");
+        
+        // Clean up temp file
+        fs.unlinkSync(overflowPath);
+      }
+    }
+  });
+
+
+
   it("should fail early when max_lines is reached", async () => {
     const tool = createBashTool({ cwd: process.cwd() });
     const startTime = performance.now();
diff --git a/src/services/tools/bash.ts b/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,
@@ -139,77 +141,87 @@ export const createBashTool: ToolFactory = (config: ToolConfiguration) => {
         const stderrReader = createInterface({ input: childProcess.child.stderr! });
 
         stdoutReader.on("line", (line) => {
-          if (!truncated && !resolved) {
-            const lineBytes = Buffer.byteLength(line, "utf-8");
-
-            // Check if line exceeds per-line limit
-            if (lineBytes > BASH_MAX_LINE_BYTES) {
-              truncated = true;
-              // Close readline interfaces before killing to ensure clean shutdown
-              stdoutReader.close();
-              stderrReader.close();
-              childProcess.child.kill();
-              return;
-            }
-
-            // Check if adding this line would exceed total bytes limit
-            if (totalBytesAccumulated + lineBytes > BASH_MAX_TOTAL_BYTES) {
-              truncated = true;
-              // Close readline interfaces before killing to ensure clean shutdown
-              stdoutReader.close();
-              stderrReader.close();
-              childProcess.child.kill();
-              return;
-            }
-
+          if (!resolved) {
+            // Always collect lines, even after truncation is triggered
+            // This allows us to save the full output to a temp file
             lines.push(line);
-            totalBytesAccumulated += lineBytes + 1; // +1 for newline
-
-            // Check if we've exceeded the effective max_lines limit
-            if (lines.length >= effectiveMaxLines) {
-              truncated = true;
-              // Close readline interfaces before killing to ensure clean shutdown
-              stdoutReader.close();
-              stderrReader.close();
-              childProcess.child.kill();
+
+            if (!truncated) {
+              const lineBytes = Buffer.byteLength(line, "utf-8");
+
+              // Check if line exceeds per-line limit
+              if (lineBytes > BASH_MAX_LINE_BYTES) {
+                truncated = true;
+                // Close readline interfaces before killing to ensure clean shutdown
+                stdoutReader.close();
+                stderrReader.close();
+                childProcess.child.kill();
+                return;
+              }
+
+              totalBytesAccumulated += lineBytes + 1; // +1 for newline
+
+              // Check if adding this line would exceed total bytes limit
+              if (totalBytesAccumulated > BASH_MAX_TOTAL_BYTES) {
+                truncated = true;
+                // Close readline interfaces before killing to ensure clean shutdown
+                stdoutReader.close();
+                stderrReader.close();
+                childProcess.child.kill();
+                return;
+              }
+
+              // Check if we've exceeded the effective max_lines limit
+              if (lines.length >= effectiveMaxLines) {
+                truncated = true;
+                // Close readline interfaces before killing to ensure clean shutdown
+                stdoutReader.close();
+                stderrReader.close();
+                childProcess.child.kill();
+              }
             }
           }
         });
 
         stderrReader.on("line", (line) => {
-          if (!truncated && !resolved) {
-            const lineBytes = Buffer.byteLength(line, "utf-8");
-
-            // Check if line exceeds per-line limit
-            if (lineBytes > BASH_MAX_LINE_BYTES) {
-              truncated = true;
-              // Close readline interfaces before killing to ensure clean shutdown
-              stdoutReader.close();
-              stderrReader.close();
-              childProcess.child.kill();
-              return;
-            }
-
-            // Check if adding this line would exceed total bytes limit
-            if (totalBytesAccumulated + lineBytes > BASH_MAX_TOTAL_BYTES) {
-              truncated = true;
-              // Close readline interfaces before killing to ensure clean shutdown
-              stdoutReader.close();
-              stderrReader.close();
-              childProcess.child.kill();
-              return;
-            }
-
+          if (!resolved) {
+            // Always collect lines, even after truncation is triggered
+            // This allows us to save the full output to a temp file
             lines.push(line);
-            totalBytesAccumulated += lineBytes + 1; // +1 for newline
-
-            // Check if we've exceeded the effective max_lines limit
-            if (lines.length >= effectiveMaxLines) {
-              truncated = true;
-              // Close readline interfaces before killing to ensure clean shutdown
-              stdoutReader.close();
-              stderrReader.close();
-              childProcess.child.kill();
+
+            if (!truncated) {
+              const lineBytes = Buffer.byteLength(line, "utf-8");
+
+              // Check if line exceeds per-line limit
+              if (lineBytes > BASH_MAX_LINE_BYTES) {
+                truncated = true;
+                // Close readline interfaces before killing to ensure clean shutdown
+                stdoutReader.close();
+                stderrReader.close();
+                childProcess.child.kill();
+                return;
+              }
+
+              totalBytesAccumulated += lineBytes + 1; // +1 for newline
+
+              // Check if adding this line would exceed total bytes limit
+              if (totalBytesAccumulated > BASH_MAX_TOTAL_BYTES) {
+                truncated = true;
+                // Close readline interfaces before killing to ensure clean shutdown
+                stdoutReader.close();
+                stderrReader.close();
+                childProcess.child.kill();
+                return;
+              }
+
+              // Check if we've exceeded the effective max_lines limit
+              if (lines.length >= effectiveMaxLines) {
+                truncated = true;
+                // Close readline interfaces before killing to ensure clean shutdown
+                stdoutReader.close();
+                stderrReader.close();
+                childProcess.child.kill();
+              }
             }
           }
         });
@@ -294,15 +306,45 @@ export const createBashTool: ToolFactory = (config: ToolConfiguration) => {
               wall_duration_ms,
             });
           } else if (truncated) {
-            // Return error when output limits exceeded - no partial output
-            resolveOnce({
-              success: false,
-              error:
-                `Command output exceeded limits (max ${BASH_MAX_TOTAL_BYTES} bytes total, ${BASH_MAX_LINE_BYTES} bytes per line, ${effectiveMaxLines} lines). ` +
-                "Use output-limiting commands like 'head', 'tail', or 'grep' to reduce output size.",
-              exitCode: -1,
-              wall_duration_ms,
-            });
+            // Save overflow output to temp file instead of returning an error
+            // We don't show ANY of the actual output to avoid overwhelming context.
+            // Instead, save it to a temp file and encourage the agent to use filtering tools.
+            try {
+              const tmpDir = os.tmpdir();
+              // Use 8 hex characters for short, memorable temp file IDs
+              const fileId = Math.random().toString(16).substring(2, 10);
+              const overflowPath = path.join(tmpDir, `bash-${fileId}.txt`);
+              const fullOutput = lines.join("\n");
+              fs.writeFileSync(overflowPath, fullOutput, "utf-8");
+
+              const output = `[OUTPUT OVERFLOW - ${lines.length} lines saved to ${overflowPath}]
+
+The command output exceeded limits and was saved to a temporary file.
+Use filtering tools to extract what you need:
+- grep '<pattern>' ${overflowPath}
+- head -n 100 ${overflowPath}
+- tail -n 100 ${overflowPath}
+- sed -n '100,200p' ${overflowPath}
+
+When done, clean up: rm ${overflowPath}`;
+
+              resolveOnce({
+                success: false,
+                error: output,
+                exitCode: -1,
+                wall_duration_ms,
+              });
+            } catch (err) {
+              // If temp file creation fails, fall back to original error
+              resolveOnce({
+                success: false,
+                error:
+                  `Command output exceeded limits (max ${BASH_MAX_TOTAL_BYTES} bytes total, ${BASH_MAX_LINE_BYTES} bytes per line, ${effectiveMaxLines} lines). ` +
+                  `Use output-limiting commands like 'head', 'tail', or 'grep' to reduce output size. Failed to save overflow: ${err}`,
+                exitCode: -1,
+                wall_duration_ms,
+              });
+            }
           } else if (exitCode === 0 || exitCode === null) {
             resolveOnce({
               success: true,
