feat: preserve tmpfile overflow logs with persistent temp directories

- Add persistentTempDir option to RunScriptOptions interface
- Implement conditional cleanup that skips deletion when tmpfile overflow occurs
- Pass persistentTempDir from tools.ts to enable overflow log preservation
- Add comprehensive test coverage for overflow and cleanup scenarios
- Clean up temp directories in error paths to prevent disk leaks

Addresses Codex review comments:
- P1: Preserve tmpfile overflow logs for script tools (scriptRunner.ts:224)
- P2: Clean up temp dirs when script execution fails (scriptRunner.ts:248)

Change-Id: I92e1492c55294bb4a5cfaaf1e572724b
Signed-off-by: Thomas Kosiewski <[email protected]>

Author: ThomasK33

src/browser/components/AIView.tsx

@@ -533,26 +533,10 @@ const AIViewInner: React.FC<AIViewProps> = ({
               <PinnedTodoList workspaceId={workspaceId} />
               {canInterrupt && (
                 <StreamingBarrier
-                  statusText={
-                    isCompacting
-                      ? currentModel
-                        ? `${getModelName(currentModel)} compacting...`
-                        : "compacting..."
-                      : currentModel
-                        ? `${getModelName(currentModel)} streaming...`
-                        : "streaming..."
-                  }
-                  cancelText={`hit ${formatKeybind(vimEnabled ? KEYBINDS.INTERRUPT_STREAM_VIM : KEYBINDS.INTERRUPT_STREAM_NORMAL)} to cancel`}
-                  tokenCount={
-                    activeStreamMessageId
-                      ? aggregator.getStreamingTokenCount(activeStreamMessageId)
-                      : undefined
-                  }
-                  tps={
-                    activeStreamMessageId
-                      ? aggregator.getStreamingTPS(activeStreamMessageId)
-                      : undefined
-                  }
+                  statusText={streamingStatusText}
+                  cancelText={streamingCancelText}
+                  tokenCount={streamingTokenCount}
+                  tps={streamingTPS}
                 />
               )}
               {workspaceState?.queuedMessage && (

src/common/utils/tools/tools.test.ts

@@ -167,6 +167,7 @@ describe("getToolsForModel", () => {
       [],
       expect.objectContaining({
         overflowPolicy: "tmpfile",
+        persistentTempDir: config.runtimeTempDir,
       })
     );
 

src/common/utils/tools/tools.ts

@@ -137,6 +137,7 @@ export async function getToolsForModel(
               secrets: config.secrets ?? {},
               timeoutSecs: 300,
               overflowPolicy: "tmpfile",
+              persistentTempDir: config.runtimeTempDir,
             }
           );
 

src/node/services/scriptRunner.persistent.test.ts

@@ -0,0 +1,142 @@
+import { describe, test, expect } from "bun:test";
+import * as path from "path";
+import * as os from "os";
+import { promises as fsPromises } from "fs";
+
+import { runWorkspaceScript } from "@/node/services/scriptRunner";
+import { LocalRuntime } from "@/node/runtime/LocalRuntime";
+
+interface WorkspaceContext {
+  workspacePath: string;
+  persistentRoot: string;
+  runtime: LocalRuntime;
+  cleanup: () => Promise<void>;
+}
+
+async function createWorkspaceWithScript(
+  scriptName: string,
+  scriptContents: string
+): Promise<WorkspaceContext> {
+  const workspacePath = await fsPromises.mkdtemp(path.join(os.tmpdir(), "mux-script-runner-"));
+
+  const scriptsDir = path.join(workspacePath, ".mux", "scripts");
+  await fsPromises.mkdir(scriptsDir, { recursive: true });
+
+  const scriptPath = path.join(scriptsDir, scriptName);
+  await fsPromises.writeFile(scriptPath, scriptContents, { mode: 0o755 });
+  await fsPromises.chmod(scriptPath, 0o755);
+
+  const persistentRoot = path.join(workspacePath, ".mux-temp-root");
+  await fsPromises.mkdir(persistentRoot, { recursive: true });
+
+  const runtime = new LocalRuntime(path.dirname(workspacePath));
+
+  const cleanup = async () => {
+    await fsPromises.rm(workspacePath, { recursive: true, force: true });
+  };
+
+  return { workspacePath, persistentRoot, runtime, cleanup };
+}
+
+function extractOverflowPath(errorText: string): string | undefined {
+  const match = /saved to (.+)/.exec(errorText);
+  return match?.[1]?.trim();
+}
+
+async function waitForDirEmpty(dir: string, timeoutMs = 2000): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const entries = await fsPromises.readdir(dir);
+      if (entries.length === 0) {
+        return true;
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        return true;
+      }
+      throw error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+
+  try {
+    const entries = await fsPromises.readdir(dir);
+    return entries.length === 0;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return true;
+    }
+    throw error;
+  }
+}
+
+describe("runWorkspaceScript persistent temp directory handling", () => {
+  const overflowScript = `#!/usr/bin/env bash
+set -euo pipefail
+node - <<'NODE'
+const chunk = '0123456789'.repeat(200);
+for (let i = 0; i < 400; i++) {
+  console.log(chunk);
+}
+NODE
+`;
+
+  const simpleScript = `#!/usr/bin/env bash
+set -euo pipefail
+echo "done"
+`;
+
+  test("preserves tmpfile overflow logs when persistent dir is provided", async () => {
+    const context = await createWorkspaceWithScript("overflow", overflowScript);
+    const { workspacePath, persistentRoot, runtime, cleanup } = context;
+
+    try {
+      const result = await runWorkspaceScript(runtime, workspacePath, "overflow", [], {
+        overflowPolicy: "tmpfile",
+        persistentTempDir: persistentRoot,
+      });
+
+      expect(result.success).toBe(true);
+      if (!result.success) {
+        throw new Error(`Expected success, got error: ${result.error}`);
+      }
+      const toolResult = result.data.toolResult;
+      expect(toolResult.success).toBe(false);
+      if (toolResult.success) {
+        throw new Error("Expected bash tool failure for overflow scenario");
+      }
+      expect(toolResult.error).toContain("OUTPUT OVERFLOW");
+
+      const overflowPath = extractOverflowPath(toolResult.error ?? "");
+      expect(overflowPath).toBeTruthy();
+      await fsPromises.access(overflowPath!);
+    } finally {
+      await fsPromises.rm(persistentRoot, { recursive: true, force: true });
+      await cleanup();
+    }
+  });
+
+  test("cleans persistent temp subdirectories when no overflow occurs", async () => {
+    const context = await createWorkspaceWithScript("light", simpleScript);
+    const { workspacePath, persistentRoot, runtime, cleanup } = context;
+
+    try {
+      const result = await runWorkspaceScript(runtime, workspacePath, "light", [], {
+        overflowPolicy: "tmpfile",
+        persistentTempDir: persistentRoot,
+      });
+
+      expect(result.success).toBe(true);
+      if (!result.success) {
+        throw new Error(`Expected success, got error: ${result.error}`);
+      }
+      expect(result.data.toolResult.success).toBe(true);
+
+      const emptied = await waitForDirEmpty(persistentRoot);
+      expect(emptied).toBe(true);
+    } finally {
+      await cleanup();
+    }
+  });
+});

src/node/services/scriptRunner.ts

@@ -36,6 +36,12 @@ export interface RunScriptOptions {
   timeoutSecs?: number;
   abortSignal?: AbortSignal;
   overflowPolicy?: "truncate" | "tmpfile";
+  /**
+   * Optional persistent temp directory root (e.g., stream-scoped ~/.mux-tmp/<token>).
+   * When provided, scriptRunner will place its temp files in a unique subdirectory inside
+   * this root so overflow logs can survive until the stream-level cleanup runs.
+   */
+  persistentTempDir?: string;
 }
 
 /**
@@ -55,6 +61,7 @@ export async function runWorkspaceScript(
     timeoutSecs = 300,
     abortSignal,
     overflowPolicy = "truncate",
+    persistentTempDir,
   } = options;
 
   // 1. Validate script name safely
@@ -120,12 +127,24 @@ export async function runWorkspaceScript(
   }
 
   // 3. Prepare temporary environment (MUX_OUTPUT, MUX_PROMPT)
-  // Create a temp directory for this execution context
-  const tempDirResult = await execBuffered(
-    runtime,
-    "mktemp -d 2>/dev/null || mktemp -d -t 'mux-script'",
-    { cwd: workspacePath, timeout: 5 }
-  );
+  // Create a temp directory for this execution context. When a persistent temp root is provided,
+  // create a unique subdirectory inside it so overflow logs survive until stream cleanup.
+  const normalizeForShell = (value: string): string => value.replace(/\\/g, "/");
+  const escapeSingleQuotes = (value: string): string => value.replace(/'/g, "'\\''");
+
+  const persistentBase =
+    persistentTempDir && persistentTempDir.trim().length > 0
+      ? normalizeForShell(persistentTempDir.trim()).replace(/\/+$/, "")
+      : undefined;
+
+  const tempDirCommand = persistentBase
+    ? `mkdir -p '${escapeSingleQuotes(persistentBase)}' && mktemp -d '${escapeSingleQuotes(`${persistentBase}/script-XXXXXX`)}'`
+    : "mktemp -d 2>/dev/null || mktemp -d -t 'mux-script'";
+
+  const tempDirResult = await execBuffered(runtime, tempDirCommand, {
+    cwd: workspacePath,
+    timeout: 5,
+  });
 
   if (tempDirResult.exitCode !== 0) {
     return Err(`Failed to prepare script environment: ${tempDirResult.stderr || "mkdir failed"}`);
@@ -136,13 +155,28 @@ export async function runWorkspaceScript(
     return Err("Failed to prepare script environment: runtime temp directory was empty");
   }
 
+  let skipCleanup = false;
+  let cleanupScheduled = false;
+  const cleanupTempDir = (): void => {
+    if (skipCleanup || cleanupScheduled) {
+      return;
+    }
+    cleanupScheduled = true;
+    const safeTempDir = runtimeTempDir.replace(/"/g, '\\"');
+    void execBuffered(runtime, `rm -rf "${safeTempDir}"`, {
+      cwd: workspacePath,
+      timeout: 5,
+    });
+  };
+
   const outputFile = path.posix.join(runtimeTempDir, "output.txt");
   const promptFile = path.posix.join(runtimeTempDir, "prompt.txt");
 
   try {
     await writeFileString(runtime, outputFile, "");
     await writeFileString(runtime, promptFile, "");
   } catch (prepError) {
+    cleanupTempDir();
     return Err(
       `Failed to prepare script environment files: ${
         prepError instanceof Error ? prepError.message : String(prepError)
@@ -220,8 +254,18 @@ export async function runWorkspaceScript(
       /* ignore */
     }
 
-    // 7. Cleanup (best effort)
-    void execBuffered(runtime, `rm -rf "${runtimeTempDir}"`, { cwd: workspacePath, timeout: 5 });
+    const indicatesTmpfileOverflow =
+      Boolean(persistentBase) &&
+      overflowPolicy === "tmpfile" &&
+      !toolResult.success &&
+      typeof toolResult.error === "string" &&
+      toolResult.error.includes("[OUTPUT OVERFLOW -");
+
+    if (indicatesTmpfileOverflow) {
+      skipCleanup = true;
+    } else {
+      cleanupTempDir();
+    }
 
     // Extract stdout/stderr based on success/failure
     let stdout = "";
@@ -243,6 +287,7 @@ export async function runWorkspaceScript(
       toolResult,
     });
   } catch (execError) {
+    cleanupTempDir();
     return Err(
       `Script execution failed: ${execError instanceof Error ? execError.message : String(execError)}`
     );