fix: consolidate memory leak fixes from 23+ community PRs

Addresses the remaining memory leaks identified in anomalyco#16697 by
consolidating the best fixes from 23+ open community PRs into
a single coherent changeset.

Fixes consolidated from PRs: anomalyco#16695, anomalyco#16346, anomalyco#14650, anomalyco#15646,

- Plugin subscriber stacking: unsub before re-subscribing in init()
- Subagent deallocation: Session.remove() after task completion
- SSE stream cleanup: centralized cleanup with done guard (3 endpoints)
- Compaction data trimming: clear output/attachments on prune
- Process exit cleanup: Instance.disposeAll() with 5s timeout
- Serve cmd: graceful shutdown instead of blocking forever
- Bash tool: ring buffer with 10MB cap instead of O(n²) concat
- LSP index teardown: clear clients/broken/spawning on dispose
- LSP open-files cap: evict oldest when >1000 tracked files
- Format subscription: store and cleanup unsub handle
- Permission/Question clearSession: reject pending on session delete
- Session.remove() cleanup chain: FileTime, Permission, Question
- ShareNext subscription cleanup: store unsub handles, cleanup on dispose
- OAuth transport: close existing before replacing

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: binarydoubling

packages/opencode/src/cli/cmd/serve.ts

@@ -5,6 +5,7 @@ import { Flag } from "../../flag/flag"
 import { Workspace } from "../../control-plane/workspace"
 import { Project } from "../../project/project"
 import { Installation } from "../../installation"
+import { Instance } from "../../project/instance"
 
 export const ServeCommand = cmd({
   command: "serve",
@@ -18,7 +19,13 @@ export const ServeCommand = cmd({
     const server = Server.listen(opts)
     console.log(`opencode server listening on http://${server.hostname}:${server.port}`)
 
-    await new Promise(() => {})
+    // Wait for termination signal instead of blocking forever
+    await new Promise<void>((resolve) => {
+      const shutdown = () => resolve()
+      process.on("SIGTERM", shutdown)
+      process.on("SIGINT", shutdown)
+    })
+    await Instance.disposeAll()
     await server.stop()
   },
 })

packages/opencode/src/control-plane/workspace-server/routes.ts

@@ -7,10 +7,25 @@ export function WorkspaceServerRoutes() {
     c.header("X-Accel-Buffering", "no")
     c.header("X-Content-Type-Options", "nosniff")
     return streamSSE(c, async (stream) => {
+      let done = false
+      let resolveStream: (() => void) | undefined
+
+      const cleanup = () => {
+        if (done) return
+        done = true
+        clearInterval(heartbeat)
+        GlobalBus.off("event", handler)
+        resolveStream?.()
+      }
+
       const send = async (event: unknown) => {
-        await stream.writeSSE({
-          data: JSON.stringify(event),
-        })
+        try {
+          await stream.writeSSE({
+            data: JSON.stringify(event),
+          })
+        } catch {
+          cleanup()
+        }
       }
       const handler = async (event: { directory?: string; payload: unknown }) => {
         await send(event.payload)
@@ -22,11 +37,8 @@ export function WorkspaceServerRoutes() {
       }, 10_000)
 
       await new Promise<void>((resolve) => {
-        stream.onAbort(() => {
-          clearInterval(heartbeat)
-          GlobalBus.off("event", handler)
-          resolve()
-        })
+        resolveStream = resolve
+        stream.onAbort(cleanup)
       })
     })
   })

packages/opencode/src/format/index.ts

@@ -101,9 +101,13 @@ export namespace Format {
     return result
   }
 
+  let unsubFormatted: (() => void) | undefined
+
   export function init() {
     log.info("init")
-    Bus.subscribe(File.Event.Edited, async (payload) => {
+    // Unsubscribe previous subscription to prevent stacking on re-init
+    unsubFormatted?.()
+    unsubFormatted = Bus.subscribe(File.Event.Edited, async (payload) => {
       const file = payload.properties.file
       log.info("formatting", { file })
       const ext = path.extname(file)

packages/opencode/src/index.ts

@@ -210,6 +210,10 @@ try {
   }
   process.exitCode = 1
 } finally {
+  // Dispose all instances (LSP, MCP, PTY child processes) to prevent zombies.
+  // Race with a 5-second timeout so we don't hang on unresponsive subprocesses.
+  const { Instance } = await import("./project/instance")
+  await Promise.race([Instance.disposeAll(), new Promise((r) => setTimeout(r, 5000))]).catch(() => {})
   // Some subprocesses don't react properly to SIGTERM and similar signals.
   // Most notably, some docker-container-based MCP servers don't handle such signals unless
   // run using `docker run --init`.

packages/opencode/src/lsp/client.ts

@@ -156,6 +156,7 @@ export namespace LSPClient {
       })
     }
 
+    const MAX_OPEN_FILES = 1000
     const files: {
       [path: string]: number
     } = {}
@@ -224,6 +225,12 @@ export namespace LSPClient {
             },
           })
           files[input.path] = 0
+          // Evict oldest file if we exceed the limit
+          const keys = Object.keys(files)
+          if (keys.length > MAX_OPEN_FILES) {
+            const oldest = keys[0]
+            delete files[oldest]
+          }
           return
         },
       },
@@ -263,6 +270,7 @@ export namespace LSPClient {
         l.info("shutting down")
         diagnostics.clear()
         diagnosticOrder.length = 0
+        for (const key of Object.keys(files)) delete files[key]
         connection.end()
         connection.dispose()
         input.server.process.kill()

packages/opencode/src/lsp/index.ts

@@ -141,6 +141,9 @@ export namespace LSP {
     },
     async (state) => {
       await Promise.all(state.clients.map((client) => client.shutdown()))
+      state.clients.length = 0
+      state.broken.clear()
+      state.spawning.clear()
     },
   )
 

packages/opencode/src/mcp/index.ts

@@ -420,7 +420,9 @@ export namespace MCP {
                 duration: 8000,
               }).catch((e) => log.debug("failed to show toast", { error: e }))
             } else {
-              // Store transport for later finishAuth call
+              // Close any existing pending transport before storing the new one
+              const existing = pendingOAuthTransports.get(key)
+              if (existing) existing.close?.().catch(() => {})
               pendingOAuthTransports.set(key, transport)
               status = { status: "needs_auth" as const }
               // Show toast for needs_auth
@@ -942,6 +944,8 @@ export namespace MCP {
   export async function removeAuth(mcpName: string): Promise<void> {
     await McpAuth.remove(mcpName)
     McpOAuthCallback.cancelPending(mcpName)
+    const transport = pendingOAuthTransports.get(mcpName)
+    if (transport) transport.close?.().catch(() => {})
     pendingOAuthTransports.delete(mcpName)
     await McpAuth.clearOAuthState(mcpName)
     log.info("removed oauth credentials", { mcpName })

packages/opencode/src/permission/next.ts

@@ -278,6 +278,21 @@ export namespace PermissionNext {
     }
   }
 
+  export async function clearSession(sessionID: string) {
+    const s = await state()
+    for (const [id, pending] of Object.entries(s.pending)) {
+      if (pending.info.sessionID === sessionID) {
+        delete s.pending[id]
+        Bus.publish(Event.Replied, {
+          sessionID: pending.info.sessionID,
+          requestID: pending.info.id,
+          reply: "reject",
+        })
+        pending.reject(new RejectedError())
+      }
+    }
+  }
+
   export async function list() {
     const s = await state()
     return Array.from(s.pending.values(), (x) => x.info)

packages/opencode/src/plugin/index.ts

@@ -130,14 +130,18 @@ export namespace Plugin {
     return state().then((x) => x.hooks)
   }
 
+  let unsub: (() => void) | undefined
+
   export async function init() {
     const hooks = await state().then((x) => x.hooks)
     const config = await Config.get()
     for (const hook of hooks) {
       // @ts-expect-error this is because we haven't moved plugin to sdk v2
       await hook.config?.(config)
     }
-    Bus.subscribeAll(async (input) => {
+    // Unsubscribe previous wildcard subscriber to prevent stacking on re-init
+    unsub?.()
+    unsub = Bus.subscribeAll(async (input) => {
       const hooks = await state().then((x) => x.hooks)
       for (const hook of hooks) {
         hook["event"]?.({

packages/opencode/src/question/index.ts

@@ -161,6 +161,20 @@ export namespace Question {
     }
   }
 
+  export async function clearSession(sessionID: string) {
+    const s = await state()
+    for (const [id, pending] of Object.entries(s.pending)) {
+      if (pending.info.sessionID === sessionID) {
+        delete s.pending[id]
+        Bus.publish(Event.Rejected, {
+          sessionID: pending.info.sessionID,
+          requestID: pending.info.id,
+        })
+        pending.reject(new RejectedError())
+      }
+    }
+  }
+
   export async function list() {
     return state().then((x) => Array.from(x.pending.values(), (x) => x.info))
   }