fix: resolve multiple memory leaks causing unbounded growth

- Cap SDK event queue to prevent unbounded growth during high event throughput
- Clean up message parts when trimming excess messages in sync store
- Evict previous session data from memory when switching sessions
- Bound LSP diagnostics map with LRU eviction and clear on shutdown
- Reject pending callbacks on session cancel to prevent promise/closure leaks

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

Author: 2 people

packages/opencode/src/cli/cmd/tui/context/sdk.tsx

@@ -38,6 +38,7 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
       [key in Event["type"]]: Extract<Event, { type: key }>
     }>()
 
+    const MAX_EVENT_QUEUE = 1000
     let queue: Event[] = []
     let timer: Timer | undefined
     let last = 0
@@ -57,6 +58,10 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
     }
 
     const handleEvent = (event: Event) => {
+      // Drop oldest events if queue is too large to prevent unbounded memory growth
+      if (queue.length >= MAX_EVENT_QUEUE) {
+        queue.splice(0, queue.length - MAX_EVENT_QUEUE + 1)
+      }
       queue.push(event)
       const elapsed = Date.now() - last
 

packages/opencode/src/cli/cmd/tui/context/sync.tsx

@@ -254,19 +254,23 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           )
           const updated = store.message[event.properties.info.sessionID]
           if (updated.length > 100) {
-            const oldest = updated[0]
+            // Remove excess messages beyond the limit, cleaning up their parts too
+            const excess = updated.length - 100
+            const removedMessages = updated.slice(0, excess)
             batch(() => {
               setStore(
                 "message",
                 event.properties.info.sessionID,
                 produce((draft) => {
-                  draft.shift()
+                  draft.splice(0, excess)
                 }),
               )
               setStore(
                 "part",
                 produce((draft) => {
-                  delete draft[oldest.id]
+                  for (const msg of removedMessages) {
+                    delete draft[msg.id]
+                  }
                 }),
               )
             })
@@ -442,6 +446,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
     })
 
     const fullSyncedSessions = new Set<string>()
+    let currentSessionID: string | undefined
     const result = {
       data: store,
       set: setStore,
@@ -468,6 +473,27 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           return last.time.completed ? "idle" : "working"
         },
         async sync(sessionID: string) {
+          // Clean up previous session's data from memory when switching sessions
+          if (currentSessionID && currentSessionID !== sessionID) {
+            const oldMessages = store.message[currentSessionID]
+            if (oldMessages) {
+              setStore(
+                produce((draft) => {
+                  // Clean up parts for old session's messages
+                  for (const msg of oldMessages) {
+                    delete draft.part[msg.id]
+                  }
+                  // Clean up old session's messages
+                  delete draft.message[currentSessionID!]
+                  // Clean up old session's diff
+                  delete draft.session_diff[currentSessionID!]
+                }),
+              )
+            }
+            fullSyncedSessions.delete(currentSessionID)
+          }
+          currentSessionID = sessionID
+
           if (fullSyncedSessions.has(sessionID)) return
           const [session, messages, todo, diff] = await Promise.all([
             sdk.client.session.get({ sessionID }, { throwOnError: true }),

packages/opencode/src/lsp/client.ts

@@ -48,15 +48,39 @@ export namespace LSPClient {
       new StreamMessageWriter(input.server.process.stdin as any),
     )
 
+    const MAX_DIAGNOSTIC_FILES = 200
     const diagnostics = new Map<string, Diagnostic[]>()
+    const diagnosticOrder: string[] = [] // track insertion order for eviction
     connection.onNotification("textDocument/publishDiagnostics", (params) => {
       const filePath = Filesystem.normalizePath(fileURLToPath(params.uri))
       l.info("textDocument/publishDiagnostics", {
         path: filePath,
         count: params.diagnostics.length,
       })
       const exists = diagnostics.has(filePath)
+
+      // If empty diagnostics, just remove the entry to free memory
+      if (params.diagnostics.length === 0) {
+        diagnostics.delete(filePath)
+        const idx = diagnosticOrder.indexOf(filePath)
+        if (idx !== -1) diagnosticOrder.splice(idx, 1)
+        if (exists) Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
+        return
+      }
+
       diagnostics.set(filePath, params.diagnostics)
+
+      // Update insertion order (move to end)
+      const idx = diagnosticOrder.indexOf(filePath)
+      if (idx !== -1) diagnosticOrder.splice(idx, 1)
+      diagnosticOrder.push(filePath)
+
+      // Evict oldest entries if we exceed the limit
+      while (diagnosticOrder.length > MAX_DIAGNOSTIC_FILES) {
+        const oldest = diagnosticOrder.shift()!
+        diagnostics.delete(oldest)
+      }
+
       if (!exists && input.serverID === "typescript") return
       Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
     })
@@ -237,6 +261,8 @@ export namespace LSPClient {
       },
       async shutdown() {
         l.info("shutting down")
+        diagnostics.clear()
+        diagnosticOrder.length = 0
         connection.end()
         connection.dispose()
         input.server.process.kill()

packages/opencode/src/session/prompt.ts

@@ -263,6 +263,11 @@ export namespace SessionPrompt {
       return
     }
     match.abort.abort()
+    // Reject any pending callbacks to prevent promise/closure leaks
+    for (const cb of match.callbacks) {
+      cb.reject(new Error("Session cancelled"))
+    }
+    match.callbacks.length = 0
     delete s[sessionID]
     SessionStatus.set(sessionID, { type: "idle" })
     return