@khalilgharbaoui/opencode-claude-code-plugin 0.4.1 → 0.4.2

package/dist/index.js

@@ -1319,52 +1319,54 @@ function writeJson(res, body) {
 
 // src/proxy-broker.ts
 import { EventEmitter as EventEmitter3 } from "events";
-var pendingBySession = /* @__PURE__ */ new Map();
+var pendingByCallId = /* @__PURE__ */ new Map();
+var callIdsBySession = /* @__PURE__ */ new Map();
 var emitter = new EventEmitter3();
 var PENDING_PROXY_CALL_TIMEOUT_MS = 10 * 60 * 1e3;
 function eventName(sessionKey2) {
   return `pending:${sessionKey2}`;
 }
+function indexAdd(sessionKey2, callId) {
+  let s = callIdsBySession.get(sessionKey2);
+  if (!s) {
+    s = /* @__PURE__ */ new Set();
+    callIdsBySession.set(sessionKey2, s);
+  }
+  s.add(callId);
+}
+function indexRemove(sessionKey2, callId) {
+  const s = callIdsBySession.get(sessionKey2);
+  if (!s) return;
+  s.delete(callId);
+  if (s.size === 0) callIdsBySession.delete(sessionKey2);
+}
 function onPendingProxyCall(sessionKey2, handler) {
   const name = eventName(sessionKey2);
   emitter.on(name, handler);
   return () => emitter.off(name, handler);
 }
 function queuePendingProxyCall(sessionKey2, call) {
-  const existing = pendingBySession.get(sessionKey2);
-  if (existing) {
-    if (Date.now() - existing.createdAt < PENDING_PROXY_CALL_TIMEOUT_MS) {
-      call.reject(
-        new Error(`Another proxy tool call is already pending for ${sessionKey2}`)
-      );
-      log.warn("rejected overlapping proxy call", {
-        sessionKey: sessionKey2,
-        existingToolCallId: existing.toolCallId,
-        existingToolName: existing.toolName,
-        toolCallId: call.id,
-        toolName: call.toolName
-      });
-      return existing;
-    }
-    clearTimeout(existing.timer);
-    existing.reject(
-      new Error(
-        `Stale proxy tool call expired after ${PENDING_PROXY_CALL_TIMEOUT_MS}ms for ${sessionKey2}`
-      )
+  const previous = pendingByCallId.get(call.id);
+  if (previous) {
+    clearTimeout(previous.timer);
+    previous.reject(
+      new Error(`Replaced pending proxy call ${call.id} with a fresh one`)
     );
-    pendingBySession.delete(sessionKey2);
+    pendingByCallId.delete(call.id);
+    indexRemove(previous.sessionKey, call.id);
   }
   const timer = setTimeout(() => {
-    const current = pendingBySession.get(sessionKey2);
-    if (!current || current.toolCallId !== call.id) return;
-    pendingBySession.delete(sessionKey2);
+    const current = pendingByCallId.get(call.id);
+    if (!current) return;
+    pendingByCallId.delete(call.id);
+    indexRemove(current.sessionKey, call.id);
     current.reject(
       new Error(
         `Proxy tool call '${call.toolName}' timed out after ${PENDING_PROXY_CALL_TIMEOUT_MS}ms waiting for opencode to resolve the call`
       )
     );
     log.warn("timed out pending proxy call", {
-      sessionKey: sessionKey2,
+      sessionKey: current.sessionKey,
       toolCallId: call.id,
       toolName: call.toolName,
       timeoutMs: PENDING_PROXY_CALL_TIMEOUT_MS
@@ -1380,7 +1382,8 @@ function queuePendingProxyCall(sessionKey2, call) {
     resolve: call.resolve,
     reject: call.reject
   };
-  pendingBySession.set(sessionKey2, pending);
+  pendingByCallId.set(call.id, pending);
+  indexAdd(sessionKey2, call.id);
   emitter.emit(eventName(sessionKey2), pending);
   log.info("queued pending proxy call", {
     sessionKey: sessionKey2,
@@ -1389,22 +1392,55 @@ function queuePendingProxyCall(sessionKey2, call) {
   });
   return pending;
 }
-function getPendingProxyCall(sessionKey2) {
-  return pendingBySession.get(sessionKey2);
+function getPendingProxyCalls(sessionKey2) {
+  const s = callIdsBySession.get(sessionKey2);
+  if (!s || s.size === 0) return [];
+  const out = [];
+  for (const id of s) {
+    const p = pendingByCallId.get(id);
+    if (p) out.push(p);
+  }
+  return out;
 }
-function resolvePendingProxyCall(sessionKey2, result) {
-  const pending = pendingBySession.get(sessionKey2);
+function resolvePendingProxyCallById(toolCallId, result) {
+  const pending = pendingByCallId.get(toolCallId);
   if (!pending) return false;
-  pendingBySession.delete(sessionKey2);
+  pendingByCallId.delete(toolCallId);
+  indexRemove(pending.sessionKey, toolCallId);
   clearTimeout(pending.timer);
   pending.resolve(result);
   log.info("resolved pending proxy call", {
-    sessionKey: sessionKey2,
+    sessionKey: pending.sessionKey,
     toolCallId: pending.toolCallId,
     toolName: pending.toolName
   });
   return true;
 }
+function rejectPendingProxyCallById(toolCallId, error) {
+  const pending = pendingByCallId.get(toolCallId);
+  if (!pending) return false;
+  pendingByCallId.delete(toolCallId);
+  indexRemove(pending.sessionKey, toolCallId);
+  clearTimeout(pending.timer);
+  pending.reject(error);
+  log.warn("rejected pending proxy call", {
+    sessionKey: pending.sessionKey,
+    toolCallId: pending.toolCallId,
+    toolName: pending.toolName,
+    error: error.message
+  });
+  return true;
+}
+function rejectAllPendingProxyCallsForSession(sessionKey2, error) {
+  const s = callIdsBySession.get(sessionKey2);
+  if (!s) return 0;
+  const ids = [...s];
+  let count = 0;
+  for (const id of ids) {
+    if (rejectPendingProxyCallById(id, error)) count++;
+  }
+  return count;
+}
 
 // src/claude-code-language-model.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
@@ -2238,8 +2274,14 @@ ${plan}
     );
     const resolvedProxy = this.resolvedProxyTools();
     const self = this;
-    const pendingProxyCall = getPendingProxyCall(sk);
-    const pendingProxyResult = pendingProxyCall ? this.extractPendingProxyResult(options.prompt, pendingProxyCall.toolCallId) : null;
+    const previousPendingProxyCalls = getPendingProxyCalls(sk);
+    const previousPendingProxyMatches = previousPendingProxyCalls.map((call) => ({
+      call,
+      result: this.extractPendingProxyResult(options.prompt, call.toolCallId)
+    }));
+    const hasMatchedPendingResults = previousPendingProxyMatches.some(
+      (m) => m.result !== null
+    );
     const runtimeStatus = await getRuntimeMcpStatus();
     log.info("doStream starting", {
       cwd,
@@ -2369,21 +2411,27 @@ ${plan}
           const skipResultForIds = /* @__PURE__ */ new Set();
           const toolCallsById = /* @__PURE__ */ new Map();
           let resultMeta = {};
-          const finishWithToolCall = (call) => {
+          const drainBuffer = [];
+          let drainTimer = null;
+          const DRAIN_QUIET_MS = 100;
+          const finishWithToolCalls = (calls) => {
             if (controllerClosed) return;
-            controller.enqueue({
-              type: "tool-input-start",
-              id: call.toolCallId,
-              toolName: call.toolName
-            });
-            controller.enqueue({
-              type: "tool-call",
-              toolCallId: call.toolCallId,
-              toolName: call.toolName,
-              input: JSON.stringify(call.input),
-              providerExecuted: false
-            });
-            skipResultForIds.add(call.toolCallId);
+            if (calls.length === 0) return;
+            for (const call of calls) {
+              controller.enqueue({
+                type: "tool-input-start",
+                id: call.toolCallId,
+                toolName: call.toolName
+              });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: call.toolCallId,
+                toolName: call.toolName,
+                input: JSON.stringify(call.input),
+                providerExecuted: false
+              });
+              skipResultForIds.add(call.toolCallId);
+            }
             controller.enqueue({
               type: "finish",
               finishReason: toFinishReason("tool-calls"),
@@ -2399,6 +2447,21 @@ ${plan}
             } catch {
             }
           };
+          const drainNow = () => {
+            if (drainTimer) {
+              clearTimeout(drainTimer);
+              drainTimer = null;
+            }
+            if (drainBuffer.length === 0) return;
+            if (controllerClosed) return;
+            const batch = drainBuffer.splice(0, drainBuffer.length);
+            log.info("draining pending proxy calls into stream finish", {
+              sessionKey: sk,
+              count: batch.length,
+              toolCallIds: batch.map((c) => c.toolCallId)
+            });
+            finishWithToolCalls(batch);
+          };
           let gotPartialEvents = false;
           const lineHandler = (line) => {
             if (!line.trim()) return;
@@ -2831,6 +2894,15 @@ ${plan}
           const closeHandler = () => {
             log.debug("readline closed");
             if (controllerClosed) return;
+            if (drainBuffer.length > 0 || getPendingProxyCalls(sk).length > 0) {
+              rejectAllPendingProxyCallsForSession(
+                sk,
+                new Error(
+                  "Claude CLI subprocess closed before pending tool calls were resolved"
+                )
+              );
+              drainBuffer.length = 0;
+            }
             controllerClosed = true;
             cleanupTurn();
             endTextBlock();
@@ -2852,6 +2924,10 @@ ${plan}
             if (cleanedUp) return;
             cleanedUp = true;
             clearFallbackTimer();
+            if (drainTimer) {
+              clearTimeout(drainTimer);
+              drainTimer = null;
+            }
             lineEmitter.off("line", lineHandler);
             lineEmitter.off("close", closeHandler);
             pendingProxyUnsubscribe?.();
@@ -2861,6 +2937,15 @@ ${plan}
           const procErrorHandler = (err) => {
             log.error("process error", { error: err.message });
             if (controllerClosed) return;
+            if (drainBuffer.length > 0 || getPendingProxyCalls(sk).length > 0) {
+              rejectAllPendingProxyCallsForSession(
+                sk,
+                new Error(
+                  `Claude CLI subprocess error: ${err.message}`
+                )
+              );
+              drainBuffer.length = 0;
+            }
             controllerClosed = true;
             cleanupTurn();
             controller.enqueue({ type: "error", error: err });
@@ -2872,12 +2957,31 @@ ${plan}
           lineEmitter.on("line", lineHandler);
           lineEmitter.on("close", closeHandler);
           pendingProxyUnsubscribe = onPendingProxyCall(sk, (call) => {
+            if (controllerClosed) {
+              log.warn(
+                "pending proxy call arrived after stream close; rejecting",
+                {
+                  sessionKey: sk,
+                  toolCallId: call.toolCallId,
+                  toolName: call.toolName
+                }
+              );
+              rejectPendingProxyCallById(
+                call.toolCallId,
+                new Error(
+                  `Pending proxy call '${call.toolName}' arrived after the stream was already closed`
+                )
+              );
+              return;
+            }
             log.info("received pending proxy call for session", {
               sessionKey: sk,
               toolCallId: call.toolCallId,
               toolName: call.toolName
             });
-            finishWithToolCall(call);
+            drainBuffer.push(call);
+            if (drainTimer) clearTimeout(drainTimer);
+            drainTimer = setTimeout(drainNow, DRAIN_QUIET_MS);
           });
           proc.on("error", procErrorHandler);
           if (options.abortSignal) {
@@ -2903,21 +3007,44 @@ ${plan}
               startResultFallback(5e3);
             });
           }
-          if (pendingProxyCall && pendingProxyResult) {
-            log.info("resolving pending proxy call from tool result prompt", {
-              sessionKey: sk,
-              toolCallId: pendingProxyCall.toolCallId,
-              toolName: pendingProxyCall.toolName
-            });
-            const resolved = resolvePendingProxyCall(sk, pendingProxyResult);
-            if (!resolved) {
-              log.warn("failed to resolve pending proxy call; no pending state", {
-                sessionKey: sk,
-                toolCallId: pendingProxyCall.toolCallId
-              });
+          if (hasMatchedPendingResults) {
+            for (const { call, result } of previousPendingProxyMatches) {
+              if (result) {
+                log.info("resolving pending proxy call from tool result prompt", {
+                  sessionKey: sk,
+                  toolCallId: call.toolCallId,
+                  toolName: call.toolName
+                });
+                resolvePendingProxyCallById(call.toolCallId, result);
+              } else {
+                log.warn(
+                  "pending proxy call had no matching tool-result; rejecting as orphan",
+                  {
+                    sessionKey: sk,
+                    toolCallId: call.toolCallId,
+                    toolName: call.toolName
+                  }
+                );
+                rejectPendingProxyCallById(
+                  call.toolCallId,
+                  new Error(
+                    `Pending proxy call '${call.toolName}' (${call.toolCallId}) was not matched in tool-result turn; rejecting as orphaned`
+                  )
+                );
+              }
             }
             return;
           }
+          if (previousPendingProxyCalls.length > 0) {
+            for (const call of previousPendingProxyCalls) {
+              rejectPendingProxyCallById(
+                call.toolCallId,
+                new Error(
+                  `Pending proxy call '${call.toolName}' (${call.toolCallId}) was orphaned by a new user turn; rejecting`
+                )
+              );
+            }
+          }
           proc.stdin?.write(userMsg + "\n");
           log.debug("sent user message", { textLength: userMsg.length });
         };