fix: add robust process exit detection for child processes

Port robust process exit detection from PR anomalyco#15757 to fix zombie/stuck
child processes in containers where Bun fails to deliver exit events.

- Add polling watchdog to bash tool and Process.spawn that detects
  process exit via kill(pid, 0) when event-loop events are missed
- Add process registry (active map) with stale/reap exports for
  server-level watchdog to detect and clean up stuck bash processes
- Improve Shell.killTree with alive() helper and proper SIGKILL
  escalation after SIGTERM timeout
- Add session-level watchdog interval in prompt loop to periodically
  reap stale bash processes

Based on the work in anomalyco#15757.

Co-Authored-By: Nacho F. Lizaur <NachoFLizaur@users.noreply.github.com>

Author: binarydoubling

packages/opencode/src/session/prompt.ts

@@ -45,6 +45,7 @@ import { LLM } from "./llm"
 import { iife } from "@/util/iife"
 import { Shell } from "@/shell/shell"
 import { Truncate } from "@/tool/truncation"
+import { stale, reap } from "@/tool/bash"
 
 // @ts-ignore
 globalThis.AI_SDK_LOG_WARNINGS = false
@@ -289,6 +290,13 @@ export namespace SessionPrompt {
 
     using _ = defer(() => cancel(sessionID))
 
+    const watchdog = setInterval(() => {
+      for (const id of stale()) {
+        reap(id)
+      }
+    }, 5000)
+    using _watchdog = defer(() => clearInterval(watchdog))
+
     // Structured output state
     // Note: On session resumption, state is reset but outputFormat is preserved
     // on the user message and will be retrieved from lastUser below

packages/opencode/src/shell/shell.ts

@@ -9,6 +9,15 @@ import { setTimeout as sleep } from "node:timers/promises"
 const SIGKILL_TIMEOUT_MS = 200
 
 export namespace Shell {
+  function alive(pid: number): boolean {
+    try {
+      process.kill(pid, 0)
+      return true
+    } catch {
+      return false
+    }
+  }
+
   export async function killTree(proc: ChildProcess, opts?: { exited?: () => boolean }): Promise<void> {
     const pid = proc.pid
     if (!pid || opts?.exited?.()) return
@@ -24,17 +33,24 @@ export namespace Shell {
 
     try {
       process.kill(-pid, "SIGTERM")
-      await sleep(SIGKILL_TIMEOUT_MS)
-      if (!opts?.exited?.()) {
-        process.kill(-pid, "SIGKILL")
-      }
-    } catch (_e) {
-      proc.kill("SIGTERM")
-      await sleep(SIGKILL_TIMEOUT_MS)
-      if (!opts?.exited?.()) {
+    } catch {
+      try {
+        proc.kill("SIGTERM")
+      } catch {}
+    }
+
+    await sleep(SIGKILL_TIMEOUT_MS)
+
+    if (opts?.exited?.() || !alive(pid)) return
+    try {
+      process.kill(-pid, "SIGKILL")
+    } catch {
+      try {
         proc.kill("SIGKILL")
-      }
+      } catch {}
     }
+
+    await sleep(SIGKILL_TIMEOUT_MS)
   }
   const BLACKLIST = new Set(["fish", "nu"])
 

packages/opencode/src/tool/bash.ts

@@ -23,6 +23,40 @@ const DEFAULT_TIMEOUT = Flag.OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS || 2
 
 export const log = Log.create({ service: "bash-tool" })
 
+// Registry for active bash processes — enables server-level watchdog
+const active = new Map<
+  string,
+  {
+    pid: number
+    timeout: number
+    started: number
+    kill: () => void
+    done: () => void
+  }
+>()
+
+export function stale() {
+  const result: string[] = []
+  const now = Date.now()
+  for (const [id, entry] of active) {
+    if (now - entry.started > entry.timeout + 5000) result.push(id)
+  }
+  return result
+}
+
+export function reap(id: string) {
+  const entry = active.get(id)
+  if (!entry) return
+  log.info("reaping stuck process", {
+    callID: id,
+    pid: entry.pid,
+    age: Date.now() - entry.started,
+  })
+  entry.kill()
+  entry.done()
+  active.delete(id)
+}
+
 const resolveWasm = (asset: string) => {
   if (asset.startsWith("file://")) return fileURLToPath(asset)
   if (asset.startsWith("/") || /^[a-z]:/i.test(asset)) return asset
@@ -180,6 +214,14 @@ export const BashTool = Tool.define("bash", async () => {
         detached: process.platform !== "win32",
       })
 
+      if (!proc.pid) {
+        if (proc.exitCode !== null) {
+          log.info("process exited before pid could be read", { exitCode: proc.exitCode })
+        } else {
+          throw new Error(`Failed to spawn process: pid is undefined for command "${params.command}"`)
+        }
+      }
+
       const MAX_OUTPUT_BYTES = 10 * 1024 * 1024 // 10 MB cap
       const outputChunks: Buffer[] = []
       let outputLen = 0
@@ -236,25 +278,72 @@ export const BashTool = Tool.define("bash", async () => {
         void kill()
       }, timeout + 100)
 
+      const callID = ctx.callID
+      if (callID) {
+        active.set(callID, {
+          pid: proc.pid!,
+          timeout,
+          started: Date.now(),
+          kill: () => Shell.killTree(proc, { exited: () => exited }),
+          done: () => {},
+        })
+      }
+
       await new Promise<void>((resolve, reject) => {
+        let resolved = false
+
         const cleanup = () => {
+          if (resolved) return
+          resolved = true
           clearTimeout(timeoutTimer)
+          clearInterval(poll)
           ctx.abort.removeEventListener("abort", abortHandler)
         }
 
-        proc.once("exit", () => {
+        const done = () => {
+          if (resolved) return
           exited = true
           cleanup()
           resolve()
-        })
+        }
 
-        proc.once("error", (error) => {
+        // Update the active entry with the real done callback
+        if (callID) {
+          const entry = active.get(callID)
+          if (entry) entry.done = done
+        }
+
+        const fail = (error: Error) => {
+          if (resolved) return
           exited = true
           cleanup()
           reject(error)
-        })
+        }
+
+        proc.once("exit", done)
+        proc.once("close", done)
+        proc.once("error", fail)
+
+        // Polling watchdog: detect process exit when Bun's event loop
+        // fails to deliver the "exit" event (confirmed Bun bug in containers)
+        const poll = setInterval(() => {
+          if (proc.exitCode !== null || proc.signalCode !== null) {
+            done()
+            return
+          }
+          if (proc.pid && process.platform !== "win32") {
+            try {
+              process.kill(proc.pid, 0)
+            } catch {
+              done()
+              return
+            }
+          }
+        }, 1000)
       })
 
+      if (callID) active.delete(callID)
+
       let output = Buffer.concat(outputChunks).toString()
       // Free the chunks array
       outputChunks.length = 0

packages/opencode/src/util/process.ts

@@ -74,20 +74,54 @@ export namespace Process {
     }
 
     const exited = new Promise<number>((resolve, reject) => {
-      const done = () => {
+      let resolved = false
+
+      const cleanup = () => {
+        if (resolved) return
+        resolved = true
         opts.abort?.removeEventListener("abort", abort)
         if (timer) clearTimeout(timer)
+        clearInterval(poll)
+      }
+
+      const finish = (code: number) => {
+        if (resolved) return
+        cleanup()
+        resolve(code)
+      }
+
+      const fail = (error: Error) => {
+        if (resolved) return
+        cleanup()
+        reject(error)
       }
 
       proc.once("exit", (code, signal) => {
-        done()
-        resolve(code ?? (signal ? 1 : 0))
+        finish(code ?? (signal ? 1 : 0))
       })
 
-      proc.once("error", (error) => {
-        done()
-        reject(error)
+      proc.once("close", (code, signal) => {
+        finish(code ?? (signal ? 1 : 0))
       })
+
+      proc.once("error", fail)
+
+      // Polling watchdog: detect process exit when Bun's event loop
+      // fails to deliver the "exit" event (confirmed Bun bug in containers)
+      const poll = setInterval(() => {
+        if (proc.exitCode !== null || proc.signalCode !== null) {
+          finish(proc.exitCode ?? (proc.signalCode ? 1 : 0))
+          return
+        }
+        if (proc.pid && process.platform !== "win32") {
+          try {
+            process.kill(proc.pid, 0)
+          } catch {
+            finish(proc.exitCode ?? 1)
+            return
+          }
+        }
+      }, 1000)
     })
 
     if (opts.abort) {