@khalilgharbaoui/opencode-claude-code-plugin 0.26.0 → 0.26.2

package/README.md

@@ -677,7 +677,9 @@ The same events are also what let a legitimately long call complete, which is th
 
 ### Per-tool proxy timeouts
 
-Deadlines still exist, as an explicit backstop rather than the mechanism that decides when a call is over. If a tool with one has not been resolved within that many milliseconds, the call is rejected and Claude receives a timeout error. Resolved per tool, most-specific layer winning:
+Deadlines still exist, as an explicit backstop rather than the mechanism that decides when a call is over. If a tool with one has not been resolved within that many milliseconds, the call is rejected and Claude receives a timeout error.
+
+A deadline does not count time opencode is still spending on the call. When it passes, the plugin asks opencode whether the session is still busy. If it is (a permission prompt waiting for your answer, or the tool itself still running), the call keeps waiting and is checked again every minute. The deadline only applies once opencode is idle, or when opencode cannot be asked. Before this, answering a permission prompt after ten minutes meant Claude had already been told the command timed out. Your late approval then cancelled Claude's next action, which it reported as you rejecting it. Resolved per tool, most-specific layer winning:
 
 1. flat default — 10 min (matches Claude CLI's own Bash ceiling)
 2. per-tool default: **`task` / `task_batch`: none**, **`question`: 30 min**, everything else: 10 min

package/dist/index.js

@@ -907,8 +907,9 @@ var QUESTION_TOOL_NAME = "question";
 var APPROVED_EXIT_PLAN_MODE_MESSAGE = "User has approved your plan. You can now start coding. Start with updating your todo list if applicable.";
 var REJECTED_EXIT_PLAN_MODE_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected. To tell you how to proceed, the user said:";
 var PLAN_MODE_APPROVAL_QUESTION = "Do you want to proceed with this plan?";
-var OPENCODE_QUESTION_RESULT_PREFIX = `User has answered your questions: "${PLAN_MODE_APPROVAL_QUESTION}"="`;
-var OPENCODE_QUESTION_RESULT_SUFFIX = `". You can now continue with the user's answers in mind.`;
+var OPENCODE_QUESTION_RESULT_PREFIX = "User has answered your questions: ";
+var OPENCODE_QUESTION_RESULT_SUFFIX = ". You can now continue with the user's answers in mind.";
+var OPENCODE_UNANSWERED = "Unanswered";
 var KEY_SEPARATOR = "\0";
 function isPlanModeQuestionActive(input) {
   if (input.compactionMode) return false;
@@ -1007,29 +1008,40 @@ function unwrapToolOutput(part) {
       return output;
   }
 }
-function unwrapOpencodeQuestionResult(value) {
-  if (value.startsWith(OPENCODE_QUESTION_RESULT_PREFIX) && value.endsWith(OPENCODE_QUESTION_RESULT_SUFFIX)) {
-    return value.slice(
-      OPENCODE_QUESTION_RESULT_PREFIX.length,
-      -OPENCODE_QUESTION_RESULT_SUFFIX.length
-    );
+function unwrapOpencodeQuestionResult(value, question) {
+  if (!value.startsWith(OPENCODE_QUESTION_RESULT_PREFIX) || !value.endsWith(OPENCODE_QUESTION_RESULT_SUFFIX)) {
+    return value;
   }
-  return value;
+  const body = value.slice(
+    OPENCODE_QUESTION_RESULT_PREFIX.length,
+    value.length - OPENCODE_QUESTION_RESULT_SUFFIX.length
+  );
+  if (!body.startsWith('"') || !body.endsWith('"')) return value;
+  let answer;
+  const head = question === void 0 ? void 0 : `"${question}"="`;
+  if (head && body.startsWith(head) && body.length > head.length) {
+    answer = body.slice(head.length, -1);
+  } else {
+    const split = body.lastIndexOf('"="');
+    if (split > 0) answer = body.slice(split + 3, -1);
+  }
+  if (answer === void 0) return value;
+  return answer === OPENCODE_UNANSWERED ? "" : answer;
 }
-function collectAnswerStrings(value) {
-  if (typeof value === "string") return [unwrapOpencodeQuestionResult(value)];
-  if (Array.isArray(value)) return value.flatMap(collectAnswerStrings);
+function collectAnswerStrings(value, question) {
+  if (typeof value === "string") return [unwrapOpencodeQuestionResult(value, question)];
+  if (Array.isArray(value)) return value.flatMap((item) => collectAnswerStrings(item, question));
   if (!value || typeof value !== "object") return [];
   const obj = value;
   if (obj.denied === true) return [String(obj.reason ?? "question rejected")];
   for (const key of ["answers", "answer", "selected", "selection", "value"]) {
-    if (key in obj) return collectAnswerStrings(obj[key]);
+    if (key in obj) return collectAnswerStrings(obj[key], question);
   }
   return [];
 }
 function classifyQuestionResult(part) {
   const output = unwrapToolOutput(part);
-  const answers = collectAnswerStrings(output).map((answer) => answer.trim()).filter(Boolean);
+  const answers = collectAnswerStrings(output, PLAN_MODE_APPROVAL_QUESTION).map((answer) => answer.trim()).filter(Boolean);
   if (answers.length === 1 && answers[0].toLowerCase() === "yes") {
     return { approved: true, feedback: "" };
   }
@@ -1175,17 +1187,18 @@ function createAccountFailoverQuestionCall(sessionKey2, input, toolCallId = `${A
   const candidates = input.candidates.map((c) => normalizeAccountName(c));
   const resets = describeReset(input.resetsAt);
   const until = resets ?? "opencode restarts";
-  pendingQuestions2.set(pendingKey2(sessionKey2, toolCallId), {
-    sourceAccount: source,
-    candidates: [...candidates],
-    resetsAt: input.resetsAt
-  });
   const question = [
     `The Claude account "${source}" is out of usage`,
     input.window ? ` in ${input.window}` : "",
     resets ? `, which resets at ${resets}` : "",
     ". Continue this task on another configured account? Leaving this unanswered waits, at no cost."
   ].join("");
+  pendingQuestions2.set(pendingKey2(sessionKey2, toolCallId), {
+    sourceAccount: source,
+    candidates: [...candidates],
+    resetsAt: input.resetsAt,
+    question
+  });
   return {
     toolCallId,
     toolName: QUESTION_TOOL_NAME,
@@ -1223,7 +1236,11 @@ function classify(pending, part) {
       reason: String(output.reason ?? "question rejected")
     };
   }
-  const answers = collectAnswerStrings(output).map((answer) => answer.trim()).filter(Boolean);
+  const outputType = part?.output?.type;
+  if (outputType === "error-text" || outputType === "error-json") {
+    return { kind: "stop", reason: String(output ?? "the form was dismissed") };
+  }
+  const answers = collectAnswerStrings(output, pending.question).map((answer) => answer.trim()).filter(Boolean);
   if (answers.length === 0) return { kind: "stop", reason: "no answer" };
   const picked = normalizeAccountName(answers[0]);
   if (picked === STOP_ANSWER) {
@@ -1240,7 +1257,7 @@ function classify(pending, part) {
     resetsAt: pending.resetsAt
   };
 }
-function consumeAccountFailoverAnswer(sessionKey2, prompt) {
+function consumeAccountFailoverAnswer(sessionKey2, prompt, fallback) {
   for (let i = prompt.length - 1; i >= 0; i--) {
     const msg = prompt[i];
     if (!Array.isArray(msg.content)) continue;
@@ -1255,6 +1272,21 @@ function consumeAccountFailoverAnswer(sessionKey2, prompt) {
       return classify(pending, part);
     }
   }
+  const last = prompt[prompt.length - 1];
+  if (fallback && fallback.candidates.length > 0 && Array.isArray(last?.content)) {
+    const orphan = last.content.find(
+      (part) => part?.type === "tool-result" && typeof part.toolCallId === "string" && part.toolCallId.startsWith(ACCOUNT_FAILOVER_TOOL_CALL_PREFIX)
+    );
+    if (orphan) {
+      return classify(
+        {
+          sourceAccount: normalizeAccountName(fallback.sourceAccount || DEFAULT_ACCOUNT),
+          candidates: fallback.candidates.map((c) => normalizeAccountName(c))
+        },
+        orphan
+      );
+    }
+  }
   return null;
 }
 function formatFailoverNote(input) {
@@ -1515,6 +1547,53 @@ function resolveProxyClientCeilingMs(overrides) {
   }
   return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
 }
+var proxyDeadlineGuard = null;
+function setProxyDeadlineGuard(guard) {
+  proxyDeadlineGuard = guard;
+}
+var PROXY_DEADLINE_RECHECK_MS = 6e4;
+var deadlineRecheckMs = PROXY_DEADLINE_RECHECK_MS;
+function armProxyDeadline(opts) {
+  let cancelled = false;
+  let extended = false;
+  let timer = null;
+  const check = async () => {
+    timer = null;
+    if (cancelled) return;
+    let keep = false;
+    const guard = proxyDeadlineGuard;
+    if (guard) {
+      try {
+        keep = await guard({ callId: opts.callId, toolName: opts.toolName });
+      } catch {
+        keep = false;
+      }
+    }
+    if (cancelled) return;
+    if (keep) {
+      if (!extended && opts.logExtension) {
+        log.warn("proxy call past its deadline, but opencode is still serving it; waiting", {
+          callId: opts.callId,
+          toolName: opts.toolName,
+          deadlineMs: opts.deadlineMs,
+          note: "usually a permission prompt in opencode; the call ends when it is answered, you abort, or the claude process goes"
+        });
+      }
+      extended = true;
+      timer = setTimeout(() => void check(), opts.recheckMs ?? deadlineRecheckMs);
+      return;
+    }
+    opts.onExpire();
+  };
+  timer = setTimeout(() => void check(), opts.deadlineMs);
+  return {
+    cancel() {
+      cancelled = true;
+      if (timer) clearTimeout(timer);
+      timer = null;
+    }
+  };
+}
 function buildProxyTimeoutError(toolName, ms) {
   const key = toolName.toLowerCase();
   const base = `Proxy tool '${toolName}' timed out after ${ms}ms waiting for opencode to resolve the call`;
@@ -2000,21 +2079,26 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
               timeoutOverrides
             );
             if (deadlineMs > PROXY_NO_DEADLINE_MS) {
-              timer = setTimeout(() => {
-                if (!pending.has(callId)) return;
-                pending.delete(callId);
-                log.notice("proxy-mcp tool call timed out", {
-                  callId,
-                  toolName,
-                  deadlineMs
-                });
-                reject2(buildProxyTimeoutError(toolName, deadlineMs));
-              }, deadlineMs);
+              timer = armProxyDeadline({
+                callId,
+                toolName,
+                deadlineMs,
+                onExpire: () => {
+                  if (!pending.has(callId)) return;
+                  pending.delete(callId);
+                  log.notice("proxy-mcp tool call timed out", {
+                    callId,
+                    toolName,
+                    deadlineMs
+                  });
+                  reject2(buildProxyTimeoutError(toolName, deadlineMs));
+                }
+              });
             }
             calls.emit("call", entry);
           }
         ).finally(() => {
-          if (timer) clearTimeout(timer);
+          timer?.cancel();
           pending.delete(callId);
         });
         if (channel.closed) {
@@ -2381,7 +2465,7 @@ var PROXY_STALL_WARNING_MS = 5 * 6e4;
 var PROXY_DEADLINE_WARNING_FRACTION = 0.6;
 var PROXY_DEADLINE_WARNING_MIN_MS = 6e4;
 function clearPendingTimers(pending) {
-  if (pending.timer) clearTimeout(pending.timer);
+  pending.timer?.cancel();
   if (pending.stallTimer) clearInterval(pending.stallTimer);
   if (pending.deadlineWarnTimer) clearTimeout(pending.deadlineWarnTimer);
 }
@@ -2425,20 +2509,26 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides, stallWarning
     call.input,
     timeoutOverrides
   );
-  const timer = deadlineMs > PROXY_NO_DEADLINE_MS ? setTimeout(() => {
-    const current = pendingByCallId.get(call.id);
-    if (!current) return;
-    pendingByCallId.delete(call.id);
-    indexRemove(current.sessionKey, call.id);
-    clearPendingTimers(current);
-    current.reject(buildProxyTimeoutError(call.toolName, deadlineMs));
-    log.notice("timed out pending proxy call", {
-      sessionKey: current.sessionKey,
-      toolCallId: call.id,
-      toolName: call.toolName,
-      deadlineMs
-    });
-  }, deadlineMs) : null;
+  const timer = deadlineMs > PROXY_NO_DEADLINE_MS ? armProxyDeadline({
+    callId: call.id,
+    toolName: call.toolName,
+    deadlineMs,
+    logExtension: true,
+    onExpire: () => {
+      const current = pendingByCallId.get(call.id);
+      if (!current) return;
+      pendingByCallId.delete(call.id);
+      indexRemove(current.sessionKey, call.id);
+      clearPendingTimers(current);
+      current.reject(buildProxyTimeoutError(call.toolName, deadlineMs));
+      log.notice("timed out pending proxy call", {
+        sessionKey: current.sessionKey,
+        toolCallId: call.id,
+        toolName: call.toolName,
+        deadlineMs
+      });
+    }
+  }) : null;
   const stallTimer = deadlineMs === PROXY_NO_DEADLINE_MS && stallWarningMs > 0 ? setInterval(() => {
     const current = pendingByCallId.get(call.id);
     if (!current) return;
@@ -2467,7 +2557,7 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides, stallWarning
       remainingMs: Math.max(0, deadlineMs - waitedMs),
       emitted: current.emitted === true,
       channelClosed: current.channel?.closed === true,
-      note: "it will be rejected when the deadline passes; raise this tool's proxyToolTimeoutMs if the work is legitimately this long"
+      note: "it will be rejected when the deadline passes unless opencode is still serving it (a permission prompt is waiting); raise this tool's proxyToolTimeoutMs if the work is legitimately this long"
     });
   }, warnAtMs) : null;
   deadlineWarnTimer?.unref?.();
@@ -2502,6 +2592,9 @@ function markPendingProxyCallEmitted(toolCallId) {
 function isPendingProxyCallChannelClosed(call) {
   return call.channel?.closed === true;
 }
+function findPendingProxyCall(toolCallId) {
+  return pendingByCallId.get(toolCallId);
+}
 function getPendingProxyCalls(sessionKey2) {
   const s = callIdsBySession.get(sessionKey2);
   if (!s || s.size === 0) return [];
@@ -4088,6 +4181,39 @@ async function fetchSessionParentId(sessionID) {
     return void 0;
   }
 }
+async function fetchSessionRunState(sessionID) {
+  if (!sessionID || sessionID === "default") return "unknown";
+  const status = opencodeClient?.session?.status;
+  if (!status) return "unknown";
+  try {
+    const res = await status.call(opencodeClient.session);
+    const data = res.data;
+    if (!data || typeof data !== "object") return "unknown";
+    const entry = data[sessionID];
+    if (!entry || typeof entry !== "object") return "idle";
+    const type = entry.type;
+    return type === "idle" ? "idle" : "busy";
+  } catch (err) {
+    log.debug("failed to read opencode session status", {
+      sessionID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return "unknown";
+  }
+}
+async function settleSessionRunState(sessionID, options = {}) {
+  const pollMs = options.pollMs ?? 150;
+  const windowMs = options.windowMs ?? 1500;
+  const started = Date.now();
+  let last = "unknown";
+  for (; ; ) {
+    const state = await fetchSessionRunState(sessionID);
+    if (state === "busy") return "busy";
+    if (state !== "unknown") last = state;
+    if (Date.now() - started >= windowMs) return last;
+    await new Promise((resolve5) => setTimeout(resolve5, pollMs));
+  }
+}
 async function getRuntimeMcpStatus() {
   const client = opencodeClient;
   if (!client?.mcp?.status) return void 0;
@@ -4821,6 +4947,7 @@ function getClaudeUserMessage(prompt, includeHistoryContext = false, opts = {})
   const compactionMode = opts.compactionMode === true;
   const cliToolCallIds = opts.cliToolCallIds;
   const content = [];
+  prompt = stripAccountFailoverParts(prompt);
   if (opts.stripContextReminders) {
     const stripped = stripContextReminders(prompt);
     if (stripped.removed > 0) {
@@ -6165,6 +6292,13 @@ import { unlink as unlink3 } from "fs/promises";
 import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
 import { randomUUID as randomUUID5 } from "crypto";
 import { dirname as dirname5, join as join8 } from "path";
+async function isProxyCallStillServed(callId) {
+  const pending = findPendingProxyCall(callId);
+  if (!pending || pending.emitted !== true) return false;
+  const session = describeSessionKey(pending.sessionKey).session;
+  return await fetchSessionRunState(session) === "busy";
+}
+setProxyDeadlineGuard(({ callId }) => isProxyCallStillServed(callId));
 var DEFAULT_COMPACTION_MODEL = "claude-haiku-4-5";
 function resolveCompactionModel(configured) {
   const env = process.env.CLAUDE_CODE_COMPACTION_MODEL?.trim();
@@ -6205,6 +6339,16 @@ function resolveOpencodeAgent(headers, providerOptions, providerKey) {
   }
   return void 0;
 }
+function describeAbortReason(reason) {
+  if (reason === void 0) return "undefined";
+  if (reason instanceof Error) return `${reason.name}: ${reason.message}`;
+  if (typeof reason === "string") return reason;
+  try {
+    return JSON.stringify(reason) ?? typeof reason;
+  } catch {
+    return typeof reason;
+  }
+}
 var KNOWN_DELTA_TYPES = /* @__PURE__ */ new Set([
   "thinking_delta",
   "text_delta",
@@ -7812,7 +7956,10 @@ ${plan}
       deleteActiveProcess(sk);
       clearCompression(sk);
     }
-    const failoverAnswer = compactionMode || useInteractive ? null : consumeAccountFailoverAnswer(sk, options.prompt);
+    const failoverAnswer = compactionMode || useInteractive ? null : consumeAccountFailoverAnswer(sk, options.prompt, {
+      sourceAccount,
+      candidates: failoverCandidates(this.config.failoverAccounts, sourceAccount)
+    });
     if (failoverAnswer?.kind === "stop") {
       log.warn("account failover declined; ending the turn", {
         sessionKey: sk,
@@ -9578,14 +9725,28 @@ ${plan}
             options.abortSignal.addEventListener("abort", () => {
               autoContinueState.aborted = true;
               if (turnCompleted || controllerClosed) {
-                if (activeProcess && activeProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0) {
-                  log.info("abort between proxy tool boundaries; releasing pending calls", { sk });
-                  void interruptTurn(activeProcess).then((idle) => {
-                    log.info("interrupt sent for aborted turn", { sk, idle });
+                const stoppedProcess = activeProcess;
+                if (stoppedProcess && stoppedProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0) {
+                  const reason = describeAbortReason(options.abortSignal?.reason);
+                  void settleSessionRunState(affinity).then((stopped) => {
+                    const stillParked = stoppedProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0;
+                    if (stopped === "busy" || !stillParked) {
+                      log.debug("abort at a tool boundary while opencode is still running the turn; keeping pending calls", {
+                        sk,
+                        session: stopped,
+                        stillParked,
+                        reason
+                      });
+                      return;
+                    }
+                    log.info("abort between proxy tool boundaries; releasing pending calls", { sk, reason });
+                    void interruptTurn(stoppedProcess).then((idle) => {
+                      log.info("interrupt sent for aborted turn", { sk, idle });
+                    });
+                    releaseAbandonedProxyCalls(
+                      "Provider stream was aborted while opencode was running its proxy tool calls"
+                    );
                   });
-                  releaseAbandonedProxyCalls(
-                    "Provider stream was aborted while opencode was running its proxy tool calls"
-                  );
                 }
                 return;
               }