fix(sse): fix zombie SSE connection memory leak

Root cause: adapter.bun.ts explicitly set idleTimeout: 0, disabling
Bun's idle timeout entirely. When connections enter TCP CLOSE_WAIT
(reverse proxy or Electron shell swallowing client FIN), the server
has no signal that the connection is dead — three resource classes
leak permanently: AsyncQueue grows without bound (14 MB/s, peak
24.5 GB), setInterval heartbeats keep ticking, Bus subscriptions
are never cancelled.

Five changes:

- server/adapter.bun.ts: idleTimeout: 0 → 120. Heartbeat interval
  is 10s so active connections reset the timer on every beat and are
  never killed; dead connections are cleaned up within 120s
- server/instance/event.ts: register c.req.raw.signal abort listener
  as a second cleanup path independent of responseReadable.cancel().
  Hono skips this listener on Bun 1.2+ (isOldBunVersion gate); we
  add it unconditionally. writeSSE try/catch kept for forward
  compatibility — Hono 4.x write() has an empty catch so this block
  does not fire on the current version
- server/instance/global.ts: same two changes applied to streamEvents()
- util/queue.ts: add capacity limit (default 1000), drop oldest entry
  on overflow — defensive backstop so growth is bounded even if a
  cleanup signal is missed
- bus/global.ts: setMaxListeners(100) — fixes #22422
  MaxListenersExceededWarning; each SSE connection adds one listener,
  default limit of 10 is too low for normal concurrent usage

Fixes #22198, fixes #22422

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 朱孟柱

packages/opencode/src/bus/global.ts

@@ -10,3 +10,4 @@ export const GlobalBus = new EventEmitter<{
     },
   ]
 }>()
+GlobalBus.setMaxListeners(100)

packages/opencode/src/server/adapter.bun.ts

@@ -11,7 +11,11 @@ export const adapter: Adapter = {
         const args = {
           fetch: app.fetch,
           hostname: opts.hostname,
-          idleTimeout: 0,
+          // Default is 10s which is too aggressive for SSE connections.
+          // 0 disables the timeout entirely — dead connections (CLOSE_WAIT) are
+          // never cleaned up, causing unbounded memory growth. 120s gives the
+          // cleanup chain enough time to fire while still bounding leak duration.
+          idleTimeout: 120,
           websocket: ws.websocket,
         } as const
         const start = (port: number) => {

packages/opencode/src/server/instance/event.ts

@@ -75,11 +75,25 @@ export const EventRoutes = () =>
         })
 
         stream.onAbort(stop)
+        // Second abort path: req.raw.signal fires before stream.onAbort on direct
+        // connections (~2ms earlier), and provides an independent cleanup path when
+        // the responseReadable.cancel() chain is broken (e.g. reverse proxy).
+        // Hono only registers this on Bun 1.0/1.1 (isOldBunVersion gate); we add
+        // it unconditionally so Bun 1.2+ is also covered.
+        c.req.raw.signal.addEventListener("abort", stop)
 
         try {
           for await (const data of q) {
             if (data === null) return
-            await stream.writeSSE({ data })
+            try {
+              await stream.writeSSE({ data })
+            } catch {
+              // Hono 4.x StreamingApi.write() has an empty catch — this block
+              // never fires on the current version. Kept for forward compatibility
+              // in case a future Hono version propagates write errors.
+              stop()
+              return
+            }
           }
         } finally {
           stop()

packages/opencode/src/server/instance/global.ts

@@ -57,11 +57,25 @@ async function streamEvents(c: Context, subscribe: (q: AsyncQueue<string | null>
     const unsub = subscribe(q)
 
     stream.onAbort(stop)
+    // Second abort path: req.raw.signal fires before stream.onAbort on direct
+    // connections (~2ms earlier), and provides an independent cleanup path when
+    // the responseReadable.cancel() chain is broken (e.g. reverse proxy).
+    // Hono only registers this on Bun 1.0/1.1 (isOldBunVersion gate); we add
+    // it unconditionally so Bun 1.2+ is also covered.
+    c.req.raw.signal.addEventListener("abort", stop)
 
     try {
       for await (const data of q) {
         if (data === null) return
-        await stream.writeSSE({ data })
+        try {
+          await stream.writeSSE({ data })
+        } catch {
+          // Hono 4.x StreamingApi.write() has an empty catch — this block
+          // never fires on the current version. Kept for forward compatibility
+          // in case a future Hono version propagates write errors.
+          stop()
+          return
+        }
       }
     } finally {
       stop()

packages/opencode/src/util/queue.ts

@@ -2,10 +2,18 @@ export class AsyncQueue<T> implements AsyncIterable<T> {
   private queue: T[] = []
   private resolvers: ((value: T) => void)[] = []
 
+  constructor(private limit = 1000) {}
+
   push(item: T) {
     const resolve = this.resolvers.shift()
-    if (resolve) resolve(item)
-    else this.queue.push(item)
+    if (resolve) {
+      resolve(item)
+    } else {
+      if (this.queue.length >= this.limit) {
+        this.queue.shift()
+      }
+      this.queue.push(item)
+    }
   }
 
   async next(): Promise<T> {