fix(bash): avoid O(n²) memory growth for large command output

Previously, output was accumulated via `output += chunk.toString()` which
creates a new string for every chunk, causing O(n²) memory usage. For
commands producing megabytes of output, this caused catastrophic memory
consumption.

Add StreamingOutput class that:
- Accumulates output in memory up to 50KB threshold
- Spills to a temp file when threshold exceeded
- Tracks bytes incrementally to avoid scanning

Fixes memory exhaustion on commands like `find /` or large builds.

Assisted-by: OpenCode (Claude Sonnet 4)

Author: cgwalters

packages/opencode/src/session/prompt.ts

@@ -29,7 +29,7 @@ import { ListTool } from "../tool/ls"
 import { FileTime } from "../file/time"
 import { Flag } from "../flag/flag"
 import { ulid } from "ulid"
-import { spawn } from "child_process"
+
 import { Command } from "../command"
 import { $, fileURLToPath } from "bun"
 import { ConfigMarkdown } from "../config/markdown"
@@ -44,7 +44,8 @@ import { SessionStatus } from "./status"
 import { LLM } from "./llm"
 import { iife } from "@/util/iife"
 import { Shell } from "@/shell/shell"
-import { Truncate } from "@/tool/truncation"
+import { Truncate, StreamingOutput } from "@/tool/truncation"
+import { spawn } from "child_process"
 
 // @ts-ignore
 globalThis.AI_SDK_LOG_WARNINGS = false
@@ -1475,39 +1476,31 @@ NOTE: At any point in time through this workflow you should feel free to ask the
     const matchingInvocation = invocations[shellName] ?? invocations[""]
     const args = matchingInvocation?.args
 
+    const streaming = new StreamingOutput()
+
     const proc = spawn(shell, args, {
       cwd: Instance.directory,
       detached: process.platform !== "win32",
-      stdio: ["ignore", "pipe", "pipe"],
       env: {
         ...process.env,
         TERM: "dumb",
       },
+      stdio: ["ignore", "pipe", "pipe"],
     })
 
-    let output = ""
-
-    proc.stdout?.on("data", (chunk) => {
-      output += chunk.toString()
+    const append = (chunk: Buffer) => {
+      const preview = streaming.append(chunk)
       if (part.state.status === "running") {
         part.state.metadata = {
-          output: output,
+          output: preview,
           description: "",
         }
         Session.updatePart(part)
       }
-    })
+    }
 
-    proc.stderr?.on("data", (chunk) => {
-      output += chunk.toString()
-      if (part.state.status === "running") {
-        part.state.metadata = {
-          output: output,
-          description: "",
-        }
-        Session.updatePart(part)
-      }
-    })
+    proc.stdout?.on("data", append)
+    proc.stderr?.on("data", append)
 
     let aborted = false
     let exited = false
@@ -1526,33 +1519,72 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 
     abort.addEventListener("abort", abortHandler, { once: true })
 
-    await new Promise<void>((resolve) => {
-      proc.on("close", () => {
-        exited = true
+    await new Promise<void>((resolve, reject) => {
+      const cleanup = () => {
         abort.removeEventListener("abort", abortHandler)
+      }
+
+      proc.once("exit", () => {
+        exited = true
+        cleanup()
+        resolve()
+      })
+
+      proc.once("error", (error) => {
+        exited = true
+        cleanup()
+        reject(error)
+      })
+
+      proc.once("close", () => {
+        exited = true
+        cleanup()
         resolve()
       })
     })
 
+    streaming.close()
+
     if (aborted) {
-      output += "\n\n" + ["<metadata>", "User aborted the command", "</metadata>"].join("\n")
+      streaming.appendMetadata("\n\n" + ["<metadata>", "User aborted the command", "</metadata>"].join("\n"))
     }
+
     msg.time.completed = Date.now()
     await Session.updateMessage(msg)
+
     if (part.state.status === "running") {
-      part.state = {
-        status: "completed",
-        time: {
-          ...part.state.time,
-          end: Date.now(),
-        },
-        input: part.state.input,
-        title: "",
-        metadata: {
+      if (streaming.truncated) {
+        part.state = {
+          status: "completed",
+          time: {
+            ...part.state.time,
+            end: Date.now(),
+          },
+          input: part.state.input,
+          title: "",
+          metadata: {
+            output: `[output streamed to file: ${streaming.totalBytes} bytes]`,
+            description: "",
+            outputPath: streaming.outputPath,
+          },
+          output: streaming.finalize(),
+        }
+      } else {
+        const output = streaming.inMemoryOutput
+        part.state = {
+          status: "completed",
+          time: {
+            ...part.state.time,
+            end: Date.now(),
+          },
+          input: part.state.input,
+          title: "",
+          metadata: {
+            output,
+            description: "",
+          },
           output,
-          description: "",
-        },
-        output,
+        }
       }
       await Session.updatePart(part)
     }

packages/opencode/src/tool/bash.ts

@@ -9,19 +9,26 @@ import { lazy } from "@/util/lazy"
 import { Language } from "web-tree-sitter"
 
 import { $ } from "bun"
-import { Filesystem } from "@/util/filesystem"
 import { fileURLToPath } from "url"
 import { Flag } from "@/flag/flag.ts"
 import { Shell } from "@/shell/shell"
 
 import { BashArity } from "@/permission/arity"
-import { Truncate } from "./truncation"
+import { Truncate, StreamingOutput } from "./truncation"
 
 const MAX_METADATA_LENGTH = 30_000
 const DEFAULT_TIMEOUT = Flag.OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS || 2 * 60 * 1000
 
 export const log = Log.create({ service: "bash-tool" })
 
+export interface BashMetadata {
+  output: string
+  exit: number | null
+  description: string
+  truncated?: boolean
+  outputPath?: string
+}
+
 const resolveWasm = (asset: string) => {
   if (asset.startsWith("file://")) return fileURLToPath(asset)
   if (asset.startsWith("/") || /^[a-z]:/i.test(asset)) return asset
@@ -80,6 +87,7 @@ export const BashTool = Tool.define("bash", async () => {
         throw new Error(`Invalid timeout value: ${params.timeout}. Timeout must be a positive number.`)
       }
       const timeout = params.timeout ?? DEFAULT_TIMEOUT
+
       const tree = await parser().then((p) => p.parse(params.command))
       if (!tree) {
         throw new Error("Failed to parse command")
@@ -154,6 +162,8 @@ export const BashTool = Tool.define("bash", async () => {
         })
       }
 
+      const streaming = new StreamingOutput()
+
       const proc = spawn(params.command, {
         shell,
         cwd,
@@ -164,8 +174,6 @@ export const BashTool = Tool.define("bash", async () => {
         detached: process.platform !== "win32",
       })
 
-      let output = ""
-
       // Initialize metadata with empty output
       ctx.metadata({
         metadata: {
@@ -175,11 +183,12 @@ export const BashTool = Tool.define("bash", async () => {
       })
 
       const append = (chunk: Buffer) => {
-        output += chunk.toString()
+        const preview = streaming.append(chunk)
+        const display =
+          preview.length > MAX_METADATA_LENGTH ? preview.slice(0, MAX_METADATA_LENGTH) + "\n\n..." : preview
         ctx.metadata({
           metadata: {
-            // truncate the metadata to avoid GIANT blobs of data (has nothing to do w/ what agent can access)
-            output: output.length > MAX_METADATA_LENGTH ? output.slice(0, MAX_METADATA_LENGTH) + "\n\n..." : output,
+            output: display,
             description: params.description,
           },
         })
@@ -228,29 +237,50 @@ export const BashTool = Tool.define("bash", async () => {
           cleanup()
           reject(error)
         })
+
+        proc.once("close", () => {
+          exited = true
+          cleanup()
+          resolve()
+        })
       })
 
-      const resultMetadata: string[] = []
+      streaming.close()
 
+      const resultMetadata: string[] = []
       if (timedOut) {
         resultMetadata.push(`bash tool terminated command after exceeding timeout ${timeout} ms`)
       }
-
       if (aborted) {
         resultMetadata.push("User aborted the command")
       }
-
       if (resultMetadata.length > 0) {
-        output += "\n\n<bash_metadata>\n" + resultMetadata.join("\n") + "\n</bash_metadata>"
+        streaming.appendMetadata("\n\n<bash_metadata>\n" + resultMetadata.join("\n") + "\n</bash_metadata>")
+      }
+
+      // If we streamed to a file (threshold exceeded), return truncated result
+      if (streaming.truncated) {
+        return {
+          title: params.description,
+          metadata: {
+            output: `[output streamed to file: ${streaming.totalBytes} bytes]`,
+            exit: proc.exitCode,
+            description: params.description,
+            truncated: true,
+            outputPath: streaming.outputPath,
+          } as BashMetadata,
+          output: streaming.finalize(),
+        }
       }
 
+      const output = streaming.inMemoryOutput
       return {
         title: params.description,
         metadata: {
           output: output.length > MAX_METADATA_LENGTH ? output.slice(0, MAX_METADATA_LENGTH) + "\n\n..." : output,
           exit: proc.exitCode,
           description: params.description,
-        },
+        } as BashMetadata,
         output,
       }
     },