@khalilgharbaoui/opencode-claude-code-plugin 0.53.2 → 0.53.3

package/dist/index.d.ts

@@ -1364,7 +1364,7 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
     private effectiveMcpConfig;
     /** Resolve ProxyToolDef[] for the configured proxyTools names. */
     private resolvedProxyTools;
-    /** Resolve ProxyToolDef[] for opencode's MCP-backed tools. */
+    /** Resolve ProxyToolDef[] for opencode's MCP-backed tools, and route the rest. */
     private resolvedProxyMcpTools;
     /** One `client.tool.list()` fetch, shaped for this turn's gates. */
     private fetchLiveToolInfo;

package/dist/index.js

@@ -4679,7 +4679,11 @@ function resolveProxyOpencodeToolDefs(options) {
   return out;
 }
 function resolveMcpProxyToolDefs(options) {
-  const empty = { defs: [], coveredServers: /* @__PURE__ */ new Set() };
+  const empty = {
+    defs: [],
+    coveredServers: /* @__PURE__ */ new Set(),
+    matchedServers: /* @__PURE__ */ new Set()
+  };
   const serverNames = options.serverNames ?? [];
   if (serverNames.length === 0) return empty;
   const tools = options.tools;
@@ -4688,6 +4692,7 @@ function resolveMcpProxyToolDefs(options) {
   const taken = options.taken ?? /* @__PURE__ */ new Set();
   const defs = [];
   const coveredServers = /* @__PURE__ */ new Set();
+  const matchedServers = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
   const collided = [];
   for (const tool of tools) {
@@ -4699,6 +4704,7 @@ function resolveMcpProxyToolDefs(options) {
       (server2) => name === server2 || name.startsWith(`${server2}_`)
     );
     if (!matchedServer) continue;
+    matchedServers.add(matchedServer);
     if (seen.has(name)) continue;
     if (taken.has(name)) {
       collided.push(name);
@@ -4718,7 +4724,7 @@ function resolveMcpProxyToolDefs(options) {
       { collided }
     );
   }
-  return { defs, coveredServers };
+  return { defs, coveredServers, matchedServers };
 }
 function readBody(req) {
   return new Promise((resolve6, reject) => {
@@ -5707,7 +5713,7 @@ async function fetchSessionRunState(sessionID, directory) {
 async function settleSessionRunState(sessionID, options = {}) {
   const pollMs = options.pollMs ?? 150;
   const windowMs = options.windowMs ?? 1500;
-  const started = Date.now();
+  const started2 = Date.now();
   let last = "unknown";
   let directory = options.directory;
   for (; ; ) {
@@ -5715,7 +5721,7 @@ async function settleSessionRunState(sessionID, options = {}) {
     const state = await fetchSessionRunState(sessionID, directory ?? "");
     if (state === "busy") return "busy";
     if (state !== "unknown") last = state;
-    if (Date.now() - started >= windowMs) return last;
+    if (Date.now() - started2 >= windowMs) return last;
     await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
 }
@@ -5765,9 +5771,9 @@ async function waitForPendingMcpServers(first, budgetMs, signal) {
   let current = first;
   const waitedFor = pendingMcpServers(current);
   if (waitedFor.length === 0) return current;
-  const started = Date.now();
+  const started2 = Date.now();
   for (; ; ) {
-    if (Date.now() - started >= budgetMs) break;
+    if (Date.now() - started2 >= budgetMs) break;
     if (signal?.aborted) break;
     await new Promise((resolve6) => setTimeout(resolve6, MCP_CONNECT_POLL_MS));
     if (signal?.aborted) break;
@@ -5781,7 +5787,7 @@ async function waitForPendingMcpServers(first, budgetMs, signal) {
     waitedFor,
     stillPending,
     budgetMs,
-    elapsedMs: Date.now() - started,
+    elapsedMs: Date.now() - started2,
     aborted: signal?.aborted === true
   });
   return current;
@@ -5909,6 +5915,56 @@ function clearBackgroundTasks(sessionKey2) {
   collected.delete(sessionKey2);
   cancelled.delete(sessionKey2);
 }
+var MAX_STARTED = 128;
+var started = /* @__PURE__ */ new Map();
+function backgroundTaskIdsIn(text) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(/<task id="([^"\s]+)" state="running">/g)) {
+    ids.add(match[1]);
+  }
+  for (const match of text.matchAll(/in the background \(sessionID: ([^)\s]+)\)/g)) {
+    ids.add(match[1]);
+  }
+  return [...ids];
+}
+function noteBackgroundDispatchResult(sessionKey2, result, now = Date.now()) {
+  if (result.kind !== "text" || result.isError === true) return;
+  for (const taskId of backgroundTaskIdsIn(result.text)) {
+    started.delete(taskId);
+    started.set(taskId, { sessionKey: sessionKey2, at: now });
+    while (started.size > MAX_STARTED) {
+      const oldest = started.keys().next();
+      if (oldest.done) break;
+      started.delete(oldest.value);
+    }
+  }
+}
+async function countRunningBackgroundTasks() {
+  const entries = [...started.entries()];
+  const cancelledIds = /* @__PURE__ */ new Set();
+  for (const ids of cancelled.values()) for (const id of ids) cancelledIds.add(id);
+  const states = await Promise.all(
+    entries.map(async ([taskId]) => {
+      if (cancelledIds.has(taskId)) return "stopped";
+      try {
+        const runState = await fetchSessionRunState(taskId);
+        if (runState !== "unknown") {
+          return isBackgroundTaskRunning(runState, []) ? "running" : "stopped";
+        }
+        const replies = await fetchSessionReplies(taskId);
+        if (replies === void 0) return "unreadable";
+        return isBackgroundTaskRunning(runState, replies) ? "running" : "stopped";
+      } catch {
+        return "unreadable";
+      }
+    })
+  );
+  return {
+    running: states.filter((state) => state === "running").length,
+    started: entries.length,
+    unreadable: states.filter((state) => state === "unreadable").length
+  };
+}
 var lastGate;
 function recordBackgroundSubagentGate(gate, now = Date.now()) {
   lastGate = { ...gate, at: now };
@@ -7635,21 +7691,21 @@ async function sessionStatus(client, sessionID) {
 async function waitForSessionIdle(client, sessionID, options = {}) {
   const pollMs = options.pollMs ?? IDLE_POLL_MS;
   const timeoutMs = options.timeoutMs ?? IDLE_WAIT_MAX_MS;
-  const started = Date.now();
+  const started2 = Date.now();
   for (; ; ) {
     if (options.stop?.()) return true;
     if (await sessionStatus(client, sessionID) !== "busy") return true;
-    if (Date.now() - started >= timeoutMs) return false;
+    if (Date.now() - started2 >= timeoutMs) return false;
     await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
 }
 async function deliverAsideInline(client, sessionID, text, options = {}) {
   const pollMs = options.inlinePollMs ?? INLINE_POLL_MS;
   const timeoutMs = options.inlineWaitMs ?? INLINE_WAIT_MAX_MS;
-  const started = Date.now();
+  const started2 = Date.now();
   for (; ; ) {
     if (emitAsideInline(sessionID, text)) return true;
-    if (Date.now() - started >= timeoutMs) return false;
+    if (Date.now() - started2 >= timeoutMs) return false;
     if (await sessionStatus(client, sessionID) !== "busy") return false;
     await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
@@ -7658,12 +7714,12 @@ async function waitForAsideProcess(client, sessionID, options = {}) {
   const pollMs = options.pollMs ?? IDLE_POLL_MS;
   const settleMs = options.settleMs ?? BUSY_SETTLE_MS;
   const spawnWaitMs = options.spawnWaitMs ?? SPAWN_WAIT_MAX_MS;
-  const started = Date.now();
+  const started2 = Date.now();
   for (; ; ) {
     const active = findActiveProcessBySessionId(sessionID);
     if (active) return active;
     const busy = await sessionStatus(client, sessionID) === "busy";
-    const waitedMs = Date.now() - started;
+    const waitedMs = Date.now() - started2;
     if (!busy && waitedMs >= settleMs) {
       log.info("btw: no live claude process for session, leaving it to the turn", { sessionID, waitedMs });
       return void 0;
@@ -7678,12 +7734,12 @@ async function waitForAsideProcess(client, sessionID, options = {}) {
 async function settleSessionBusy(client, sessionID, active, options = {}) {
   const pollMs = options.pollMs ?? IDLE_POLL_MS;
   const settleMs = options.settleMs ?? BUSY_SETTLE_MS;
-  const started = Date.now();
+  const started2 = Date.now();
   for (; ; ) {
     const status = await sessionStatus(client, sessionID);
     if (status === "busy") return true;
     if (status === "unknown") return isProcessBusy(active);
-    if (Date.now() - started >= settleMs) return false;
+    if (Date.now() - started2 >= settleMs) return false;
     await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
 }
@@ -7787,7 +7843,7 @@ async function handleBtwCommand(client, input, options = {}) {
     );
   }
   if (!busy) return;
-  const started = Date.now();
+  const started2 = Date.now();
   const outcome = await Promise.race([
     inlineDelivered,
     waitForSessionIdle(client, input.sessionID, { ...options, stop: () => inlineDone }).then(
@@ -7797,14 +7853,14 @@ async function handleBtwCommand(client, input, options = {}) {
   if (outcome === "inline") {
     log.info("btw: answered inside the running turn, dropping the /btw message", {
       sessionID: input.sessionID,
-      waitedMs: Date.now() - started
+      waitedMs: Date.now() - started2
     });
     throw new BtwHandledError(BTW_INLINE_HANDLED_MESSAGE);
   }
   log.info("btw: turn over, releasing the /btw message", {
     sessionID: input.sessionID,
     idle: outcome === "idle",
-    waitedMs: Date.now() - started
+    waitedMs: Date.now() - started2
   });
   if (outcome === "timeout") {
     showToast(client, { title: "btw", message: BTW_TURN_TOO_LONG_MESSAGE, variant: "warning", duration: 8e3 });
@@ -7933,6 +7989,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "proxy-mcp interceptor failed",
   "proxy-mcp rejected a request",
   "proxy-mcp tool call timed out",
+  "proxyOpencodeMcpTools cannot route V2 Code Mode's MCP tools, which reach the model through execute; for Code Mode, explicitly allowlist execute in proxyOpencodeTools and use bridgeOpencodeMcp: false with strictMcpConfig: true",
   "proxyOpencodeTools entry dropped: a proxy tool already holds that name, and it keeps it",
   "proxyOpencodeTools is set but opencode's tool registry did not answer; forwarding nothing this spawn",
   "refusing the pid-named scratch directory",
@@ -9168,6 +9225,10 @@ function formatDoctorReport(report) {
 }
 function formatBackgroundSubagents(state) {
   const lines = [];
+  if (state.running) {
+    lines.push(...formatRunningCount(state.running));
+    lines.push("");
+  }
   const gate = state.gate;
   if (!gate) {
     lines.push(
@@ -9213,6 +9274,19 @@ function formatBackgroundSubagents(state) {
   }
   return lines;
 }
+function formatRunningCount(count) {
+  if (count.started === 0) {
+    return ["running now: 0 (none started by this process)"];
+  }
+  const lines = [`running now: ${count.running} (of ${count.started} started by this process)`];
+  if (count.unreadable > 0) {
+    lines.push("");
+    lines.push(
+      `${count.unreadable} could not be read from opencode (deleted, or no session route on this build) and are not counted as running.`
+    );
+  }
+  return lines;
+}
 function describeBackgroundGateSource(gate) {
   if (gate.hostApi === "v2") {
     return "opencode 2 offers `background` unconditionally, so the registry is not consulted";
@@ -9297,7 +9371,8 @@ async function gatherDoctorReport(options) {
     planUsage,
     backgroundSubagents: {
       gate: snapshotBackgroundSubagentGate(),
-      ledgers: snapshotBackgroundTasks()
+      ledgers: snapshotBackgroundTasks(),
+      running: await countRunningBackgroundTasks().catch(() => void 0)
     }
   };
 }
@@ -11968,12 +12043,12 @@ function spawnInteractiveProcess(opts) {
         }
       }
       closeProxyServer();
-      const started = startPromise !== null;
+      const started2 = startPromise !== null;
       try {
         session.dispose();
       } catch {
       }
-      if (!started && proc.exitCode === null && proc.signalCode === null) {
+      if (!started2 && proc.exitCode === null && proc.signalCode === null) {
         proc.signalCode = "SIGTERM";
         proc.emit("exit", null, "SIGTERM");
         proc.emit("close", null, "SIGTERM");
@@ -12737,7 +12812,13 @@ function resolvedProxyTools(config) {
   }
   return picked.length > 0 ? picked : null;
 }
-function resolvedProxyMcpTools(config, allEnabledServerNames, modelTools, taken) {
+function decideMcpServerRoute(input) {
+  if (input.covered) return "proxy";
+  if (input.inToolSet) return "bridge";
+  if (input.toolSetKnown && input.status === "connected") return "withhold";
+  return "bridge";
+}
+function resolvedProxyMcpTools(config, allEnabledServerNames, modelTools, taken, runtimeStatus) {
   if (config.proxyOpencodeMcpTools !== true) return null;
   if (config.bridgeOpencodeMcp === false) return null;
   if (allEnabledServerNames.length === 0) return null;
@@ -12746,18 +12827,47 @@ function resolvedProxyMcpTools(config, allEnabledServerNames, modelTools, taken)
     tools: modelTools,
     taken
   });
-  if (resolution.defs.length === 0) {
+  const codeMode = config.hostApi === "v2" && (modelTools?.some((tool) => tool.name === "execute") ?? false);
+  const toolSetKnown = (modelTools?.length ?? 0) > 0 && !codeMode;
+  const withheld = [];
+  const bridged = [];
+  for (const server2 of allEnabledServerNames) {
+    const route = decideMcpServerRoute({
+      covered: resolution.coveredServers.has(server2),
+      inToolSet: resolution.matchedServers.has(server2),
+      status: runtimeStatus?.[server2],
+      toolSetKnown
+    });
+    if (route === "withhold") withheld.push(server2);
+    else if (route === "bridge") bridged.push(server2);
+  }
+  if (codeMode && resolution.defs.length === 0) {
     log.warn(
-      "proxyOpencodeMcpTools is on but no MCP tool was found in opencode's tool set; those servers stay on the direct bridge this spawn" + (config.hostApi === "v2" && modelTools?.some((tool) => tool.name === "execute") ? ". For V2 Code Mode, explicitly allowlist execute in proxyOpencodeTools and use bridgeOpencodeMcp: false with strictMcpConfig: true" : ""),
-      { servers: allEnabledServerNames, modelTools: modelTools?.length ?? 0 }
+      "proxyOpencodeMcpTools cannot route V2 Code Mode's MCP tools, which reach the model through execute; for Code Mode, explicitly allowlist execute in proxyOpencodeTools and use bridgeOpencodeMcp: false with strictMcpConfig: true",
+      { servers: allEnabledServerNames }
     );
-    return null;
   }
-  log.debug("routing opencode MCP tools through the proxy", {
-    servers: [...resolution.coveredServers],
-    tools: resolution.defs.map((def) => def.name)
-  });
-  return resolution;
+  if (withheld.length > 0 || bridged.length > 0) {
+    log.info("proxyOpencodeMcpTools: MCP servers outside this agent's tool set", {
+      proxied: [...resolution.coveredServers],
+      withheld,
+      bridged,
+      modelTools: modelTools?.length ?? 0,
+      statusKnown: runtimeStatus !== void 0
+    });
+  } else {
+    log.debug("routing opencode MCP tools through the proxy", {
+      servers: [...resolution.coveredServers],
+      tools: resolution.defs.map((def) => def.name)
+    });
+  }
+  const exclude = /* @__PURE__ */ new Set([...resolution.coveredServers, ...withheld]);
+  return {
+    resolution,
+    withheld,
+    bridged,
+    excludeServers: exclude.size > 0 ? exclude : void 0
+  };
 }
 async function fetchLiveToolInfo(config, modelId) {
   const items = await fetchOpencodeToolList(
@@ -14684,13 +14794,14 @@ var ClaudeCodeLanguageModel = class {
   resolvedProxyTools() {
     return resolvedProxyTools(this.config);
   }
-  /** Resolve ProxyToolDef[] for opencode's MCP-backed tools. */
-  resolvedProxyMcpTools(allEnabledServerNames, modelTools, taken) {
+  /** Resolve ProxyToolDef[] for opencode's MCP-backed tools, and route the rest. */
+  resolvedProxyMcpTools(allEnabledServerNames, modelTools, taken, runtimeStatus) {
     return resolvedProxyMcpTools(
       this.config,
       allEnabledServerNames,
       modelTools,
-      taken
+      taken,
+      runtimeStatus
     );
   }
   /** One `client.tool.list()` fetch, shaped for this turn's gates. */
@@ -15999,13 +16110,14 @@ var ClaudeCodeLanguageModel = class {
               void 0,
               runtimeStatus
             );
-            const mcpResolution = self.resolvedProxyMcpTools(
+            const mcpRouting = self.resolvedProxyMcpTools(
               discovery.allEnabledServerNames,
               options.tools,
-              new Set((resolvedProxy ?? []).map((def) => def.name))
+              new Set((resolvedProxy ?? []).map((def) => def.name)),
+              runtimeStatus
             );
-            const proxyMcpTools = mcpResolution?.defs ?? null;
-            const excludeServers = mcpResolution ? mcpResolution.coveredServers : void 0;
+            const proxyMcpTools = mcpRouting && mcpRouting.resolution.defs.length > 0 ? mcpRouting.resolution.defs : null;
+            const excludeServers = mcpRouting?.excludeServers;
             const taskProxyEnabled = resolvedProxy?.some((t) => t.name === "task") ?? false;
             const questionProxyEnabled = resolvedProxy?.some((t) => t.name === "question") ?? false;
             const opencodeToolsRequested = (self.config.proxyOpencodeTools?.length ?? 0) > 0;
@@ -16861,6 +16973,9 @@ var ClaudeCodeLanguageModel = class {
                     recoveryRequired: channelClosed || state.unattendedTurnEnded
                   });
                 }
+                if (call.toolName === "task" || call.toolName === TASK_BATCH_TOOL_NAME) {
+                  noteBackgroundDispatchResult(sk, result);
+                }
                 resolvePendingProxyCallById(call.toolCallId, result);
               } else {
                 log.info(