@khalilgharbaoui/opencode-claude-code-plugin 0.39.0 → 0.40.0

package/dist/index.js

@@ -4887,6 +4887,9 @@ function noteInteractiveProcessExit(sessionKey2, ap, code) {
   if (activeProcesses.get(sessionKey2) !== ap) return;
   cancelIdleProcessEviction(sessionKey2);
   activeProcesses.delete(sessionKey2);
+  if (getPendingProxyCalls(sessionKey2).length > 0) {
+    rejectAllPendingProxyCallsForSession(sessionKey2, new Error(CHILD_EXITED_MESSAGE));
+  }
   if (code !== 0 && code !== null) {
     claudeSessions.delete(sessionKey2);
     forgetResumePoint(sessionKey2);
@@ -8772,6 +8775,8 @@ var ClaudeSession = class {
   trustMoves = 0;
   trustMovedAt = 0;
   turn = null;
+  /** The running turn's read state, shared with `flushTranscript`. */
+  scan = null;
   turnDenied = [];
   abandonTurn = false;
   o;
@@ -9084,67 +9089,103 @@ var ClaudeSession = class {
         this.proc.terminal.write(prompt);
       }
       await this.submitTurn();
-      let stopReason = null;
-      let stopSeenAt = 0;
-      let end = null;
-      let sawUserRecord = false;
-      let lastBeat = Date.now();
+      const scan = {
+        onRecord,
+        stopReason: null,
+        stopSeenAt: 0,
+        end: null,
+        sawUserRecord: false,
+        lastBeat: Date.now()
+      };
+      this.scan = scan;
       const deadline = Date.now() + timeout;
       while (Date.now() < deadline) {
         await delay(this.o.pollMs);
         if (this.aborted) throw new Error("aborted mid-turn");
         const fatalNow = this.fatalError();
         if (fatalNow) throw fatalNow;
-        const lines = this.readRawLines();
-        const lastComplete = lines.length - 1;
-        if (lastComplete > this.cursor) {
-          for (let i = this.cursor; i < lastComplete && !end; i++) {
-            const s = lines[i];
-            if (!s || !s.trim()) continue;
-            let rec = null;
-            try {
-              rec = JSON.parse(s);
-            } catch {
-            }
-            onRecord(s, rec);
-            if (!rec) continue;
-            if (rec.type === "assistant" && rec.message) {
-              const reason = rec.message.stop_reason;
-              if (typeof reason === "string") {
-                stopReason = TERMINAL_STOP.has(reason) ? reason : null;
-              }
-            } else if (rec.type === "user") {
-              if (sawUserRecord && isInterruptRecord(rec)) end = "interrupted";
-              sawUserRecord = true;
-            } else if ((sawUserRecord || stopReason) && isTurnDurationRecord(rec)) {
-              end = stopReason ? "stop" : "ended";
-            }
-            this.cursor = i + 1;
+        if (this.scanTranscript() || scan.end) {
+          if (scan.end) {
+            return {
+              stopReason: scan.end === "stop" ? scan.stopReason : null,
+              end: scan.end,
+              denied: this.turnDenied
+            };
           }
-          if (!end) this.cursor = lastComplete;
-          lastBeat = Date.now();
-          stopSeenAt = Date.now();
-          if (end) return { stopReason: end === "stop" ? stopReason : null, end, denied: this.turnDenied };
           continue;
         }
-        if (stopReason && Date.now() - stopSeenAt >= this.o.stopSettleMs) {
-          return { stopReason, end: "stop", denied: this.turnDenied };
+        if (scan.stopReason && Date.now() - scan.stopSeenAt >= this.o.stopSettleMs) {
+          return { stopReason: scan.stopReason, end: "stop", denied: this.turnDenied };
         }
         if (this.exited) throw new Error(this.failureMessage("claude exited mid-turn", true));
         if (this.abandonTurn) return { stopReason: null, end: "interrupted", denied: this.turnDenied };
         const now = Date.now();
-        if (onHeartbeat && now - lastBeat >= this.o.heartbeatMs) {
-          lastBeat = now;
+        if (onHeartbeat && now - scan.lastBeat >= this.o.heartbeatMs) {
+          scan.lastBeat = now;
           if (now - this.lastDataAt < this.o.heartbeatMs) onHeartbeat();
         }
       }
       return { stopReason: null, end: null, denied: this.turnDenied };
     } finally {
       this.turn = null;
+      this.scan = null;
       this.abandonTurn = false;
       settle();
     }
   }
+  /**
+   * Read every complete transcript record past the cursor into the running
+   * turn. Returns whether anything new was read. The one place a record is
+   * interpreted, shared by the poll loop and `flushTranscript`.
+   */
+  scanTranscript() {
+    const scan = this.scan;
+    if (!scan || scan.end) return false;
+    const lines = this.readRawLines();
+    const lastComplete = lines.length - 1;
+    if (lastComplete <= this.cursor) return false;
+    for (let i = this.cursor; i < lastComplete && !scan.end; i++) {
+      const s = lines[i];
+      if (!s || !s.trim()) {
+        this.cursor = i + 1;
+        continue;
+      }
+      let rec = null;
+      try {
+        rec = JSON.parse(s);
+      } catch {
+      }
+      scan.onRecord(s, rec);
+      if (rec) {
+        if (rec.type === "assistant" && rec.message) {
+          const reason = rec.message.stop_reason;
+          if (typeof reason === "string") {
+            scan.stopReason = TERMINAL_STOP.has(reason) ? reason : null;
+          }
+        } else if (rec.type === "user") {
+          if (scan.sawUserRecord && isInterruptRecord(rec)) scan.end = "interrupted";
+          scan.sawUserRecord = true;
+        } else if ((scan.sawUserRecord || scan.stopReason) && isTurnDurationRecord(rec)) {
+          scan.end = scan.stopReason ? "stop" : "ended";
+        }
+      }
+      this.cursor = i + 1;
+    }
+    if (!scan.end) this.cursor = lastComplete;
+    scan.lastBeat = Date.now();
+    scan.stopSeenAt = Date.now();
+    return true;
+  }
+  /**
+   * Hand the running turn every record the TUI has already written, now
+   * rather than at the next poll. The TUI writes a reply's records before it
+   * runs the reply's tools, but a proxied tool's MCP call can reach the
+   * plugin inside one poll interval, and the step it ends must not close
+   * before the text that preceded the call was read. No-op between turns.
+   */
+  flushTranscript() {
+    this.scanTranscript();
+  }
   /**
    * Stop the running turn the way the TUI's own Esc does, and keep the
    * session alive for the next one. Resolves true once the turn ended, false
@@ -9316,6 +9357,9 @@ function interactiveExtraArgs(opts) {
       "--strict-mcp-config"
     );
   }
+  if (opts.disallowedTools && opts.disallowedTools.length > 0) {
+    extraArgs.push("--disallowedTools", ...opts.disallowedTools);
+  }
   for (const dir of opts.pluginDirs ?? []) {
     extraArgs.push("--plugin-dir", dir);
   }
@@ -9415,12 +9459,30 @@ function interactiveResultFrame(opts) {
     duration_ms: 0
   });
 }
+function carriesReplyText(line) {
+  try {
+    const rec = JSON.parse(line);
+    if (rec?.type !== "assistant" || !Array.isArray(rec.message?.content)) return false;
+    return rec.message.content.some(
+      (block) => block?.type === "text" && typeof block.text === "string" && block.text.trim()
+    );
+  } catch {
+    return false;
+  }
+}
 function spawnInteractiveProcess(opts) {
   const extraArgs = interactiveExtraArgs(opts);
   const openCalls = new OpenToolCalls();
   let denials = [];
   const lineEmitter = new EventEmitter4();
   const proc = new EventEmitter4();
+  let ap;
+  let proxyClosed = false;
+  const closeProxyServer = () => {
+    if (proxyClosed || !opts.proxyServer) return;
+    proxyClosed = true;
+    void opts.proxyServer.close();
+  };
   const session = new ClaudeSession({
     ...opts.tuning,
     cwd: opts.cwd,
@@ -9450,6 +9512,7 @@ function spawnInteractiveProcess(opts) {
     onExit: (code) => {
       proc.exitCode = code;
       proc.signalCode = code === null ? "SIGTERM" : null;
+      closeProxyServer();
       log.info("interactive claude exited", { sessionId: session.sessionId, code });
       proc.emit("exit", proc.exitCode, proc.signalCode);
       proc.emit("close", proc.exitCode, proc.signalCode);
@@ -9477,7 +9540,12 @@ function spawnInteractiveProcess(opts) {
   const runTurn = async (userMsg, turnNumber) => {
     const current = () => turnNumber === writes;
     const emit2 = (line) => {
-      if (current()) lineEmitter.emit("line", line);
+      if (!current()) return;
+      if (lineEmitter.listenerCount("line") === 0) {
+        if (carriesReplyText(line)) bufferUnattendedLine(ap, line);
+        return;
+      }
+      lineEmitter.emit("line", line);
     };
     try {
       await ensureStarted();
@@ -9497,7 +9565,13 @@ function spawnInteractiveProcess(opts) {
           emit2(raw);
         },
         void 0,
-        () => emit2(heartbeatFrame(session.sessionId, openCalls.newest()))
+        // Only to a listening turn: it feeds that turn's watchdog, and the
+        // TUI redraws its spinner the whole time it waits on a proxied call.
+        () => {
+          if (lineEmitter.listenerCount("line") > 0) {
+            emit2(heartbeatFrame(session.sessionId, openCalls.newest()));
+          }
+        }
       );
       log.info("interactive turn ended", {
         end,
@@ -9570,6 +9644,7 @@ function spawnInteractiveProcess(opts) {
           });
         }
       }
+      closeProxyServer();
       const started = startPromise !== null;
       try {
         session.dispose();
@@ -9583,11 +9658,13 @@ function spawnInteractiveProcess(opts) {
       return true;
     }
   });
-  return {
+  ap = {
     proc,
     lineEmitter,
-    proxyServer: null,
+    proxyServer: opts.proxyServer ?? null,
     mcpHash: void 0,
+    unattendedLines: [],
+    unattendedDropped: 0,
     systemPromptFile: opts.systemPromptFile,
     cliPath: opts.cliPath,
     interactiveControl: {
@@ -9597,9 +9674,11 @@ function spawnInteractiveProcess(opts) {
       interrupt: (timeoutMs) => {
         cancelledThrough = writes;
         return session.interrupt(timeoutMs);
-      }
+      },
+      flushTranscript: () => session.flushTranscript()
     }
   };
+  return ap;
 }
 
 // src/prompts.ts
@@ -11162,6 +11241,8 @@ function drainNow(state) {
   }
   if (state.drainBuffer.length === 0) return;
   if (state.controllerClosed) return;
+  state.activeProcess?.interactiveControl?.flushTranscript();
+  if (state.controllerClosed) return;
   const batch = state.drainBuffer.splice(0, state.drainBuffer.length);
   log.info("draining pending proxy calls into stream finish", {
     sessionKey: state.sessionKey,
@@ -13015,13 +13096,145 @@ var ClaudeCodeLanguageModel = class {
               state.proxyServer = null;
             }
           }
+          const resolveProxyWiring = async () => {
+            const discovery = self.effectiveMcpConfig(
+              cwd,
+              void 0,
+              runtimeStatus
+            );
+            const mcpResolution = self.resolvedProxyMcpTools(
+              discovery.allEnabledServerNames,
+              options.tools,
+              new Set((resolvedProxy ?? []).map((def) => def.name))
+            );
+            const proxyMcpTools = mcpResolution?.defs ?? null;
+            const excludeServers = mcpResolution ? mcpResolution.coveredServers : void 0;
+            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;
+            log.debug("opencode tool forwarding gate", {
+              requested: self.config.proxyOpencodeTools ?? null,
+              opencodeToolsRequested
+            });
+            const liveToolInfo = taskProxyEnabled || questionProxyEnabled || opencodeToolsRequested ? await loadLiveToolInfo() : {
+              resolved: false,
+              taskDescription: void 0,
+              taskParameters: void 0,
+              questionDescription: void 0,
+              hasQuestion: false
+            };
+            let enrichedProxy = resolvedProxy;
+            let backgroundSubagentsSupported = false;
+            if (enrichedProxy && taskProxyEnabled) {
+              enrichedProxy = overlayTaskProxyDescription(
+                enrichedProxy,
+                liveToolInfo.taskDescription
+              );
+              log.info("task proxy description overlay", {
+                applied: Boolean(liveToolInfo.taskDescription),
+                liveDescriptionLength: liveToolInfo.taskDescription?.length ?? 0,
+                listsAgentTypes: Boolean(
+                  liveToolInfo.taskDescription?.includes(
+                    "Available agent types"
+                  )
+                )
+              });
+              const hostDialect = self.config.hostApi === "v2" ? "v2" : "v1";
+              backgroundSubagentsSupported = liveTaskSupportsBackground(
+                liveToolInfo.taskParameters,
+                hostDialect
+              );
+              enrichedProxy = applyBackgroundSubagentSupport(
+                enrichedProxy,
+                backgroundSubagentsSupported,
+                hostDialect
+              );
+              recordBackgroundSubagentGate({
+                supported: backgroundSubagentsSupported,
+                hostApi: hostDialect,
+                registryResolved: liveToolInfo.resolved
+              });
+              log.info("background subagent gate", {
+                supported: backgroundSubagentsSupported,
+                registryResolved: liveToolInfo.resolved,
+                hostApi: hostDialect,
+                note: backgroundSubagentsSupported ? "task accepts `background`; task_status and task_cancel are registered" : "`background` stripped from the task schema; set OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true in opencode's environment to enable it"
+              });
+            }
+            if (enrichedProxy && questionProxyEnabled) {
+              enrichedProxy = overlayQuestionProxyDescription(
+                enrichedProxy,
+                liveToolInfo.hasQuestion ? liveToolInfo.questionDescription : void 0
+              );
+              enrichedProxy = filterQuestionProxyByOpencodeSupport(
+                enrichedProxy,
+                liveToolInfo.hasQuestion
+              );
+              log.info("question proxy version gate", {
+                opencodeHasQuestion: liveToolInfo.hasQuestion,
+                kept: liveToolInfo.hasQuestion
+              });
+            }
+            const opencodeToolDefs = resolveProxyOpencodeToolDefs({
+              requested: self.config.proxyOpencodeTools,
+              items: liveToolInfo.items,
+              modelTools: self.config.hostApi === "v2" ? options.tools ?? [] : void 0,
+              allowCodeExecution: self.config.permissionPreset !== "read-only",
+              taken: new Set(
+                [...enrichedProxy ?? [], ...proxyMcpTools ?? []].map(
+                  (t) => t.name
+                )
+              )
+            });
+            if (opencodeToolDefs.length > 0) {
+              log.info("forwarding opencode tools through the proxy", {
+                tools: opencodeToolDefs.map((t) => t.name)
+              });
+            }
+            const combinedList = [
+              ...enrichedProxy ?? [],
+              ...proxyMcpTools ?? [],
+              ...opencodeToolDefs
+            ];
+            const combinedProxyTools = combinedList.length > 0 ? combinedList : null;
+            const pluginCompressEnabled = enrichedProxy?.some((t) => t.name === "compress") ?? false;
+            if (!state.proxyServer && combinedProxyTools) {
+              state.proxyServer = await self.ensureProxyServer(
+                combinedProxyTools,
+                sk,
+                pluginCompressEnabled,
+                affinity
+              );
+            }
+            const questionProxyActive = enrichedProxy?.some((t) => t.name === "question") ?? false;
+            const allDisallowed = resolveDisallowedTools({
+              proxyTools: enrichedProxy,
+              extraDisallowedTools: self.config.extraDisallowedTools,
+              disableWebSearch: self.config.webSearch === "disabled"
+            });
+            return {
+              excludeServers,
+              taskProxyEnabled,
+              backgroundSubagentsSupported,
+              questionProxyActive,
+              opencodeToolDefs,
+              pluginCompressEnabled,
+              allDisallowed
+            };
+          };
           if (useInteractive && !compactionMode) {
-            const mcp = self.effectiveMcpConfig(cwd, void 0, runtimeStatus);
             if (state.activeProcess) {
               state.proc = state.activeProcess.proc;
               state.lineEmitter = state.activeProcess.lineEmitter;
               log.debug("reusing active interactive session", { sk });
             } else {
+              const wiring = await resolveProxyWiring();
+              const mcp = self.effectiveMcpConfig(
+                cwd,
+                state.proxyServer?.configPath(),
+                runtimeStatus,
+                wiring.excludeServers
+              );
               const allow = [
                 ...mcp.allEnabledServerNames.map((n) => `mcp__${n}__*`),
                 "mcp__opencode_proxy__*",
@@ -13035,12 +13248,27 @@ var ClaudeCodeLanguageModel = class {
               ];
               const systemPromptFile = self.config.interactiveSystemPrompt === false ? void 0 : buildAppendedSystemPrompt(
                 cwd,
-                self.config.multiStepContinuation !== false
+                self.config.multiStepContinuation !== false,
                 // Do not forward opencode's own system prompt into the
                 // interactive TUI. Live subscription-account testing
                 // showed that large forwarded payload can trigger Claude
                 // Code's third-party-app usage gate, while our static
-                // CLI/AGENTS/continuation prompt remains safe.
+                // CLI/AGENTS/continuation prompt remains safe. The
+                // plugin's own short proxy hints are part of that static
+                // prompt: without them the model narrates a subagent
+                // dispatch instead of calling the proxy (h #g74).
+                [
+                  ...wiring.taskProxyEnabled ? [SUBAGENT_DISPATCH_HINT] : [],
+                  ...wiring.backgroundSubagentsSupported ? [BACKGROUND_SUBAGENT_HINT] : [],
+                  ...wiring.questionProxyActive ? [QUESTION_PROXY_HINT] : []
+                ],
+                {
+                  compressEnabled: wiring.pluginCompressEnabled,
+                  opencodeCompressEnabled: wiring.opencodeToolDefs.some(
+                    (t) => t.name === "compress"
+                  ),
+                  compressionSummary: getCompressionSummary(sk)
+                }
               );
               if (self.config.interactiveSystemPrompt === false) {
                 log.warn(
@@ -13069,6 +13297,8 @@ var ClaudeCodeLanguageModel = class {
                 mcpConfigPaths: mcp.paths,
                 pluginDirs: skillPluginDirs,
                 permissionsAllow: allow,
+                disallowedTools: wiring.allDisallowed,
+                proxyServer: state.proxyServer,
                 systemPromptFile,
                 ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey,
                 effort: reasoningEffort,
@@ -13115,121 +13345,15 @@ var ClaudeCodeLanguageModel = class {
                 cliVersion
               });
             } else {
-              const discovery = self.effectiveMcpConfig(
-                cwd,
-                void 0,
-                runtimeStatus
-              );
-              const mcpResolution = self.resolvedProxyMcpTools(
-                discovery.allEnabledServerNames,
-                options.tools,
-                new Set((resolvedProxy ?? []).map((def) => def.name))
-              );
-              const proxyMcpTools = mcpResolution?.defs ?? null;
-              const excludeServers = mcpResolution ? mcpResolution.coveredServers : void 0;
-              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;
-              log.debug("opencode tool forwarding gate", {
-                requested: self.config.proxyOpencodeTools ?? null,
-                opencodeToolsRequested
-              });
-              const liveToolInfo = taskProxyEnabled || questionProxyEnabled || opencodeToolsRequested ? await loadLiveToolInfo() : {
-                resolved: false,
-                taskDescription: void 0,
-                taskParameters: void 0,
-                questionDescription: void 0,
-                hasQuestion: false
-              };
-              let enrichedProxy = resolvedProxy;
-              let backgroundSubagentsSupported = false;
-              if (enrichedProxy && taskProxyEnabled) {
-                enrichedProxy = overlayTaskProxyDescription(
-                  enrichedProxy,
-                  liveToolInfo.taskDescription
-                );
-                log.info("task proxy description overlay", {
-                  applied: Boolean(liveToolInfo.taskDescription),
-                  liveDescriptionLength: liveToolInfo.taskDescription?.length ?? 0,
-                  listsAgentTypes: Boolean(
-                    liveToolInfo.taskDescription?.includes(
-                      "Available agent types"
-                    )
-                  )
-                });
-                const hostDialect = self.config.hostApi === "v2" ? "v2" : "v1";
-                backgroundSubagentsSupported = liveTaskSupportsBackground(
-                  liveToolInfo.taskParameters,
-                  hostDialect
-                );
-                enrichedProxy = applyBackgroundSubagentSupport(
-                  enrichedProxy,
-                  backgroundSubagentsSupported,
-                  hostDialect
-                );
-                recordBackgroundSubagentGate({
-                  supported: backgroundSubagentsSupported,
-                  hostApi: hostDialect,
-                  registryResolved: liveToolInfo.resolved
-                });
-                log.info("background subagent gate", {
-                  supported: backgroundSubagentsSupported,
-                  registryResolved: liveToolInfo.resolved,
-                  hostApi: hostDialect,
-                  note: backgroundSubagentsSupported ? "task accepts `background`; task_status and task_cancel are registered" : "`background` stripped from the task schema; set OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true in opencode's environment to enable it"
-                });
-              }
-              if (enrichedProxy && questionProxyEnabled) {
-                enrichedProxy = overlayQuestionProxyDescription(
-                  enrichedProxy,
-                  liveToolInfo.hasQuestion ? liveToolInfo.questionDescription : void 0
-                );
-                enrichedProxy = filterQuestionProxyByOpencodeSupport(
-                  enrichedProxy,
-                  liveToolInfo.hasQuestion
-                );
-                log.info("question proxy version gate", {
-                  opencodeHasQuestion: liveToolInfo.hasQuestion,
-                  kept: liveToolInfo.hasQuestion
-                });
-              }
-              const opencodeToolDefs = resolveProxyOpencodeToolDefs({
-                requested: self.config.proxyOpencodeTools,
-                items: liveToolInfo.items,
-                modelTools: self.config.hostApi === "v2" ? options.tools ?? [] : void 0,
-                allowCodeExecution: self.config.permissionPreset !== "read-only",
-                taken: new Set(
-                  [...enrichedProxy ?? [], ...proxyMcpTools ?? []].map(
-                    (t) => t.name
-                  )
-                )
-              });
-              if (opencodeToolDefs.length > 0) {
-                log.info("forwarding opencode tools through the proxy", {
-                  tools: opencodeToolDefs.map((t) => t.name)
-                });
-              }
-              const combinedList = [
-                ...enrichedProxy ?? [],
-                ...proxyMcpTools ?? [],
-                ...opencodeToolDefs
-              ];
-              const combinedProxyTools = combinedList.length > 0 ? combinedList : null;
-              const pluginCompressEnabled = enrichedProxy?.some((t) => t.name === "compress") ?? false;
-              if (!state.proxyServer && combinedProxyTools) {
-                state.proxyServer = await self.ensureProxyServer(
-                  combinedProxyTools,
-                  sk,
-                  pluginCompressEnabled,
-                  affinity
-                );
-              }
-              const questionProxyActive = enrichedProxy?.some((t) => t.name === "question") ?? false;
-              const allDisallowed = resolveDisallowedTools({
-                proxyTools: enrichedProxy,
-                extraDisallowedTools: self.config.extraDisallowedTools,
-                disableWebSearch: self.config.webSearch === "disabled"
-              });
+              const {
+                excludeServers,
+                taskProxyEnabled,
+                backgroundSubagentsSupported,
+                questionProxyActive,
+                opencodeToolDefs,
+                pluginCompressEnabled,
+                allDisallowed
+              } = await resolveProxyWiring();
               const mcp = self.effectiveMcpConfig(
                 cwd,
                 state.proxyServer?.configPath(),