@khalilgharbaoui/opencode-claude-code-plugin 0.34.0 → 0.34.1

package/README.md

@@ -469,7 +469,7 @@ reaches the CLI, so there is nothing there to fall back from.
 | `mcpConfig` | string \| string[] | – | Extra `--mcp-config` paths/JSON passed alongside the bridged config. |
 | `strictMcpConfig` | boolean | `false` | Pass `--strict-mcp-config` so Claude loads **only** the configured servers and ignores `~/.claude/settings.json`. |
 | `hotReloadMcp` | boolean | `true` | With MCP bridging on, compare the merged MCP config and runtime status at the start of each turn and respawn the `claude` process when they drifted, so a server you just enabled, disabled or finished connecting becomes visible without restarting opencode or opening a new chat. It only ever acts at a safe boundary: never during `/compact`, never on the interactive transport, never while a proxied call is still in the air, a turn is still running or a plan-mode approval is outstanding, and the Claude session id is preserved for `--resume` so the conversation continues. A log line at INFO names which servers joined and left. A server that flaps buys at most one respawn per minute per conversation (`CLAUDE_CODE_MCP_HOT_RELOAD_COOLDOWN_MS`). Set `false` to keep a cached subprocess until the chat is reset. It does not reload other provider options and does not watch the contents of files named in `mcpConfig`. |
-| `mcpConnectWaitMs` | number | `3000` | How long the first turn of a conversation waits for MCP servers opencode reports as still connecting before planning the `claude` spawn without them. Only opencode 2 can report that state (`pending`); opencode 1's own status call blocks until every server has decided, so this budget is what makes the two majors behave alike. Set `0` to always plan with whatever the host says at that instant. A server slower than the budget is not lost either way: it is still bridged, and `hotReloadMcp` moves the conversation onto a process that has it on the next turn. |
+| `mcpConnectWaitMs` | number | `3000` | How long the first turn of a conversation waits for MCP servers opencode reports as still connecting before planning the `claude` spawn without them. Only opencode 2 can report that state (`pending`); opencode 1's own status call blocks until every server has decided, so this budget is what makes the two majors behave alike. Set `0` to always plan with whatever the host says at that instant. Aborting the turn also ends the wait at once. A server slower than the budget is not lost either way: it is still bridged, and `hotReloadMcp` moves the conversation onto a process that has it on the next turn. |
 | `proxyOpencodeMcpTools` | boolean | `false` | Route opencode's MCP-backed tools through the in-process `opencode_proxy` server instead of bridging them straight into Claude's `--mcp-config`, so each call executes once, inside opencode, with its permission prompt and its tool row. **The default changed from `true` to `false` in this release, and no behaviour changed with it:** at `true` it used to route nothing at all, because discovery read opencode's tool registry, which contains built-ins and plugin-declared tools and has never contained an MCP tool. Discovery now reads the model tool set opencode passes the provider, which is where MCP tools actually are, so the option works, and turning it on is the operator's decision rather than a silent migration of traffic that the direct bridge is handling today. Two caveats before enabling it: pair it with `strictMcpConfig: true`, because a server also registered in Claude Code's own config is reached directly and bypasses the proxy entirely; and a routed call runs in opencode with the calling agent's permissions, the same trade [`proxyOpencodeTools`](#options-reference) makes. Servers whose tools are not found stay on the direct bridge, and a warning says so, so do not treat this as an exactly-once guarantee for write-capable tools. |
 | `proxyOpencodeTools` | string[] | `[]` | Forward explicitly named opencode tools through the proxy (for example, a plugin's `compress` or V2 Code Mode `execute`). V1 uses registry ids; V2 uses the current model tool snapshot, including its real JSON Schema and agent visibility, not the registry's empty schemas. A forwarded tool runs inside opencode with the calling agent's permissions. A name already held by a proxy def is dropped with a warning. The read-only preset refuses `execute`. See [Forwarding opencode's own tools](#forwarding-opencode-s-own-tools) and [V2 Code Mode](#v2-code-mode). |
 | `stripContextReminders` | boolean | `false` | Remove opencode-dcp's `<dcp-system-reminder>` blocks from message text when no `compress` tool is proxied, so an order the model cannot follow stops being re-sent with every message that carries it. Inert as soon as `compress` is reachable. See [Trimming unsatisfiable context reminders](#trimming-unsatisfiable-context-reminders). |
@@ -851,7 +851,7 @@ A proxied call ends when something happens to it, not when a clock runs out. The
 | What happens | What the plugin does |
 |---|---|
 | opencode returns the tool's result | resolves the call; the CLI gets the result and carries on |
-| you abort the turn (Esc / Ctrl+C) | sends the CLI an `interrupt`, which answers with its own result, and rejects every call the turn had pending, whether the abort lands before content, mid-turn, or while opencode is running the tool between two stream boundaries |
+| you abort the turn (Esc / Ctrl+C) | sends the CLI an `interrupt`, which answers with its own result, and rejects every call the turn had pending, whether the abort lands before content, mid-turn, or while opencode is running the tool between two stream boundaries. A stop that lands before the turn has asked the CLI for anything is the one exception: it interrupts nothing and releases nothing, because the calls still pending there belong to the previous step and the next message orphans them as usual |
 | you send the next message in that chat | rejects every call the previous turn left pending as orphaned, so the CLI gets an error result and the new turn starts clean |
 | the `claude` process closes its output or exits, mid-turn or between turns | rejects its pending calls; a mid-turn death also ends the turn as a visible error |
 | you delete the chat in opencode, or opencode exits | kills the worker and rejects its pending calls |
@@ -1145,6 +1145,7 @@ Each chat keeps a long-lived `claude` subprocess so the model retains its native
 - **New chat** → fresh process under the new session key.
 - **Resumed chat after restart** → in-memory state is gone; a new process spawns and the conversation history is summarized and prepended.
 - **Abort (Esc / Ctrl+C)** → the plugin sends the Claude CLI a stream-json `interrupt` control request, so the CLI actually stops generating and running tools instead of finishing the abandoned turn on your bill. The process stays alive for the next message in that chat, and any proxied call the aborted turn left behind is released when that message arrives (see [How a proxied call ends](#how-a-proxied-call-ends)). If a turn is somehow still running when the next one starts, it is interrupted first (5 s cap). Contributed by [@broskees](https://github.com/broskees).
+- **Abort during the first moment of a turn** → a turn spends a little time preparing before it asks the CLI for anything: resolving the spawn directory, probing the `claude` version, reading opencode's MCP status and tool registry. A stop pressed in that window used to be dropped, and the turn spawned, ran and billed anyway. It now ends the turn there: nothing is spawned, nothing is written, no running process is interrupted, and the reply is simply empty.
 - **Idle timeout** → when `idleProcessTimeoutMs` is set, a completed headless turn arms an eviction timer (unset or `0` keeps workers until LRU eviction). Reuse cancels it, a worker found mid-turn when it fires is left alone and re-timed, and eviction preserves the session id, so the next message resumes the same conversation with `--resume`. An idle `claude --print` holds around 250 MB, which is the reason to set it if you keep many chats open.
 - **Cap**: 16 active processes, LRU eviction. A process that is mid-turn is never the victim: eviction takes the oldest **idle** one, and when every process is busy it evicts nothing and warns instead, so a running answer is never truncated to make room.
 - **Deleted chat** → deleting a session in opencode kills its `claude` workers at once and forgets their session ids and per-chat state; there is nothing left to resume. Other chats, and the shared fallback bucket used when no session id is known, are untouched.

package/dist/index.js

@@ -3504,16 +3504,18 @@ async function getRuntimeMcpStatus(options = {}) {
   const current = await fetchRuntimeMcpStatus();
   const budgetMs = options.waitForPendingMs ?? 0;
   if (!current || budgetMs <= 0) return current;
-  return waitForPendingMcpServers(current, budgetMs);
+  return waitForPendingMcpServers(current, budgetMs, options.signal);
 }
-async function waitForPendingMcpServers(first, budgetMs) {
+async function waitForPendingMcpServers(first, budgetMs, signal) {
   let current = first;
   const waitedFor = pendingMcpServers(current);
   if (waitedFor.length === 0) return current;
   const started = Date.now();
   for (; ; ) {
     if (Date.now() - started >= budgetMs) break;
+    if (signal?.aborted) break;
     await new Promise((resolve6) => setTimeout(resolve6, MCP_CONNECT_POLL_MS));
+    if (signal?.aborted) break;
     const next = await fetchRuntimeMcpStatus();
     if (!next) break;
     current = next;
@@ -3524,7 +3526,8 @@ async function waitForPendingMcpServers(first, budgetMs) {
     waitedFor,
     stillPending,
     budgetMs,
-    elapsedMs: Date.now() - started
+    elapsedMs: Date.now() - started,
+    aborted: signal?.aborted === true
   });
   return current;
 }
@@ -8621,6 +8624,8 @@ function createTurnState(init) {
     reasoningIds: /* @__PURE__ */ new Map(),
     reasoningStarted: /* @__PURE__ */ new Map(),
     hadThinkingTextFromStream: false,
+    cliAskedForWork: false,
+    streamStarted: false,
     turnCompleted: false,
     controllerClosed: false,
     cleanedUp: false,
@@ -8670,6 +8675,59 @@ function createTurnState(init) {
   return state;
 }
 
+// src/turn-abort.ts
+function watchTurnAbort(signal) {
+  let aborted = signal?.aborted === true;
+  let listeners = [];
+  let settle;
+  const whenAborted = new Promise((resolve6) => {
+    settle = resolve6;
+  });
+  const fire = () => {
+    if (aborted && listeners === null) return;
+    aborted = true;
+    const pending = listeners ?? [];
+    listeners = null;
+    settle();
+    for (const fn of pending) {
+      try {
+        fn();
+      } catch (error) {
+        log.warn("turn abort listener threw", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+  const onSignalAbort = () => fire();
+  if (aborted) {
+    listeners = null;
+    settle();
+  } else {
+    signal?.addEventListener("abort", onSignalAbort, { once: true });
+  }
+  return {
+    get aborted() {
+      return aborted;
+    },
+    get reason() {
+      return signal?.reason;
+    },
+    whenAborted,
+    onAbort(fn) {
+      if (aborted) {
+        fn();
+        return;
+      }
+      listeners?.push(fn);
+    },
+    dispose() {
+      listeners = null;
+      signal?.removeEventListener("abort", onSignalAbort);
+    }
+  };
+}
+
 // src/stream-parser.ts
 import { generateId as generateId2 } from "@ai-sdk/provider-utils";
 
@@ -10344,6 +10402,21 @@ var ClaudeCodeLanguageModel = class {
   }
   async doStreamForHost(options, attempt, mode = "stream") {
     const warnings = [];
+    const turnAbort = watchTurnAbort(options.abortSignal);
+    const abortedBeforeWork = (stage) => {
+      log.info("abort before the turn asked claude for work; nothing spawned", {
+        stage,
+        reason: describeAbortReason(turnAbort.reason)
+      });
+      turnAbort.dispose();
+      const aborted = new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "stream-start", warnings });
+          controller.close();
+        }
+      });
+      return { stream: aborted, request: { body: { text: "" } } };
+    };
     const skipPermissions = this.config.skipPermissions !== false;
     const scope = this.requestScope(options);
     const affinity = this.sessionAffinity(options);
@@ -10388,6 +10461,7 @@ var ClaudeCodeLanguageModel = class {
       modelId: effectiveModelId
     });
     let cliPath = failover.cliPath;
+    if (turnAbort.aborted) return abortedBeforeWork("resolving the spawn cwd and account");
     const asideTransportRef = { cliPath, interactive: !!useInteractive };
     const doctor = !compactionMode && scope !== "no-tools" ? parseDoctorCommand(options.prompt) : null;
     if (doctor) {
@@ -10639,7 +10713,7 @@ var ClaudeCodeLanguageModel = class {
     const hasMatchedPendingResults = previousPendingProxyMatches.some(
       (m) => m.result !== null
     );
-    const [runtimeStatus, cliVersion] = await Promise.all([
+    const prologueWork = Promise.all([
       compactionMode ? Promise.resolve(void 0) : getRuntimeMcpStatus({
         // Give a server opencode is still starting a bounded moment to
         // reach a decision before the spawn is planned without it. Only
@@ -10647,10 +10721,20 @@ var ClaudeCodeLanguageModel = class {
         // call exactly as before.
         waitForPendingMs: resolveMcpConnectWaitMs(
           this.config.mcpConnectWaitMs
-        )
+        ),
+        signal: options.abortSignal
       }),
       detectCliVersion(cliPath)
     ]);
+    prologueWork.catch(() => void 0);
+    const prologue = await Promise.race([
+      prologueWork.then((value) => ({ value })),
+      turnAbort.whenAborted.then(() => void 0)
+    ]);
+    if (!prologue) {
+      return abortedBeforeWork("waiting for opencode's MCP status and the CLI version");
+    }
+    const [runtimeStatus, cliVersion] = prologue.value;
     const failoverAccounts = failoverCandidates(
       this.config.failoverAccounts,
       sourceAccount
@@ -10681,6 +10765,7 @@ var ClaudeCodeLanguageModel = class {
       opencodeAgent: this.getOpencodeAgent(options),
       providerOptionsKeys: options.providerOptions ? Object.keys(options.providerOptions) : []
     });
+    if (turnAbort.aborted) return abortedBeforeWork("planning the spawn");
     const stream = new ReadableStream({
       start(controller) {
         if (compactionMode) {
@@ -10710,7 +10795,109 @@ var ClaudeCodeLanguageModel = class {
         });
         state.activeProcess = getActiveProcess(sk);
         state.proxyServer = state.activeProcess?.proxyServer ?? null;
+        const discardUnattachedProxyServer = () => {
+          const own = state.proxyServer;
+          if (!own || own === state.activeProcess?.proxyServer) return;
+          state.proxyServer = null;
+          void own.close().catch((error) => {
+            log.warn("failed to close the proxy server of an aborted turn", {
+              sessionKey: sk,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          });
+        };
+        const releaseAbandonedProxyCalls = (reason) => {
+          if (state.drainBuffer.length === 0 && getPendingProxyCalls(sk).length === 0) return;
+          rejectAllPendingProxyCallsForSession(sk, new Error(reason));
+          state.drainBuffer.length = 0;
+        };
+        turnAbort.onAbort(() => {
+          state.autoContinueState.aborted = true;
+          if (!state.cliAskedForWork) {
+            if (state.controllerClosed) return;
+            state.controllerClosed = true;
+            log.info("abort while the turn was still being prepared; nothing was sent to claude", {
+              sessionKey: sk,
+              // A process here was spawned by this turn or reused from an
+              // earlier one; either way nothing was asked of it.
+              attachedProcess: !!state.activeProcess,
+              reason: describeAbortReason(turnAbort.reason)
+            });
+            discardUnattachedProxyServer();
+            state.cleanupTurn?.();
+            if (!state.streamStarted) {
+              state.streamStarted = true;
+              controller.enqueue({ type: "stream-start", warnings });
+            }
+            try {
+              controller.close();
+            } catch {
+            }
+            return;
+          }
+          if (state.turnCompleted || state.controllerClosed) {
+            const stoppedProcess = state.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"
+                );
+              });
+            }
+            return;
+          }
+          if (state.activeProcess) {
+            void interruptTurn(state.activeProcess).then((idle) => {
+              log.info("interrupt sent for aborted turn", { sk, idle });
+            });
+          }
+          if (!state.hasReceivedContent) {
+            log.info(
+              "abort signal received before content, closing stream immediately",
+              { cwd }
+            );
+            releaseAbandonedProxyCalls(
+              "Provider stream was aborted before pending proxy calls were emitted"
+            );
+            state.controllerClosed = true;
+            state.cleanupTurn?.();
+            try {
+              controller.close();
+            } catch {
+            }
+            return;
+          }
+          log.info(
+            "abort signal received mid-turn, starting grace period",
+            { cwd }
+          );
+          releaseAbandonedProxyCalls(
+            "Provider stream was aborted while proxy tool calls were pending"
+          );
+          startResultFallback(state, 5e3);
+        });
+        const stoppedBeforeWork = () => {
+          if (!state.controllerClosed || state.cliAskedForWork) return false;
+          discardUnattachedProxyServer();
+          return true;
+        };
         const setup = async () => {
+          if (stoppedBeforeWork()) return;
           if (!compactionMode && state.activeProcess && self.config.hotReloadMcp !== false && self.config.bridgeOpencodeMcp !== false) {
             const probe = self.effectiveMcpConfig(cwd, void 0, runtimeStatus);
             const previousHash = state.activeProcess.mcpHash ?? null;
@@ -10783,6 +10970,7 @@ var ClaudeCodeLanguageModel = class {
                 enabled: self.config.bridgeOpencodeSkills === true,
                 ...self.skillBridgeSpawn(failover)
               });
+              if (stoppedBeforeWork()) return;
               const ap = spawnInteractiveProcess({
                 cwd,
                 cliPath,
@@ -10989,6 +11177,7 @@ var ClaudeCodeLanguageModel = class {
               spawnMcpHash = mcp.bridgedHash;
               spawnMcpServers = mcp.allEnabledServerNames;
             }
+            if (stoppedBeforeWork()) return;
             if (state.activeProcess && !compactionMode) {
               state.proc = state.activeProcess.proc;
               state.lineEmitter = state.activeProcess.lineEmitter;
@@ -11019,6 +11208,8 @@ var ClaudeCodeLanguageModel = class {
               log.warn("previous turn did not stop in time; this turn may see stale output", { sk });
             }
           }
+          if (stoppedBeforeWork()) return;
+          state.streamStarted = true;
           controller.enqueue({ type: "stream-start", warnings });
           if (failoverNote) {
             controller.enqueue({
@@ -11377,72 +11568,8 @@ var ClaudeCodeLanguageModel = class {
             state.drainTimer = setTimeout(() => drainNow(state), DRAIN_QUIET_MS);
           });
           state.proc.on("error", procErrorHandler);
-          if (options.abortSignal) {
-            const releaseAbandonedProxyCalls = (reason) => {
-              if (state.drainBuffer.length === 0 && getPendingProxyCalls(sk).length === 0) return;
-              rejectAllPendingProxyCallsForSession(sk, new Error(reason));
-              state.drainBuffer.length = 0;
-            };
-            options.abortSignal.addEventListener("abort", () => {
-              state.autoContinueState.aborted = true;
-              if (state.turnCompleted || state.controllerClosed) {
-                const stoppedProcess = state.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"
-                    );
-                  });
-                }
-                return;
-              }
-              if (state.activeProcess) {
-                void interruptTurn(state.activeProcess).then((idle) => {
-                  log.info("interrupt sent for aborted turn", { sk, idle });
-                });
-              }
-              if (!state.hasReceivedContent) {
-                log.info(
-                  "abort signal received before content, closing stream immediately",
-                  { cwd }
-                );
-                releaseAbandonedProxyCalls(
-                  "Provider stream was aborted before pending proxy calls were emitted"
-                );
-                state.controllerClosed = true;
-                cleanupTurn();
-                try {
-                  controller.close();
-                } catch {
-                }
-                return;
-              }
-              log.info(
-                "abort signal received mid-turn, starting grace period",
-                { cwd }
-              );
-              releaseAbandonedProxyCalls(
-                "Provider stream was aborted while proxy tool calls were pending"
-              );
-              startResultFallback(state, 5e3);
-            });
-          }
           if (hasMatchedPendingResults) {
+            state.cliAskedForWork = true;
             for (const { call, result } of previousPendingProxyMatches) {
               if (result) {
                 const channelClosed = isPendingProxyCallChannelClosed(call);
@@ -11500,6 +11627,7 @@ var ClaudeCodeLanguageModel = class {
               );
             }
           }
+          state.cliAskedForWork = true;
           if (state.activeProcess) noteTurnStarted(state.activeProcess);
           state.proc.stdin?.write(userMsg + "\n");
           log.debug("sent user message", { textLength: userMsg.length });