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

package/dist/index.d.ts

@@ -114,6 +114,7 @@ interface ClaudeCodeConfig {
     proxyTools?: string[];
     webSearch?: WebSearchRouting;
     hotReloadMcp?: boolean;
+    proxyOpencodeMcpTools?: boolean;
 }
 type WebSearchRouting = "claude" | "disabled" | (string & {});
 interface ClaudeCodeProviderSettings {
@@ -191,6 +192,21 @@ interface ClaudeCodeProviderSettings {
      * survives MCP changes until the chat is reset).
      */
     hotReloadMcp?: boolean;
+    /**
+     * Route opencode MCP server tools through the in-process `opencode_proxy`
+     * MCP server instead of bridging them directly into Claude CLI's
+     * `--mcp-config`. With both layers configured for the same MCP server,
+     * direct bridging causes each tool invocation to execute twice — once by
+     * Claude CLI's own MCP child process and once by opencode. Routing through
+     * the proxy keeps a single execution site (opencode) while preserving the
+     * tool-call/result surface in opencode's UI and its permission prompts.
+     *
+     * Defaults to `true`. Set to `false` to restore the prior direct-bridge
+     * behavior (Claude CLI executes MCP tools itself; opencode also re-executes
+     * — accept the duplication if you need Claude to invoke the tool without
+     * an opencode round-trip).
+     */
+    proxyOpencodeMcpTools?: boolean;
 }
 type PermissionMode = "acceptEdits" | "auto" | "bypassPermissions" | "default" | "dontAsk" | "plan";
 type ControlRequestBehavior = "allow" | "deny";
@@ -305,6 +321,16 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
     private effectiveMcpConfig;
     /** Resolve ProxyToolDef[] for the configured proxyTools names. */
     private resolvedProxyTools;
+    /**
+     * Resolve ProxyToolDef[] for opencode's MCP-bridged tools so they go
+     * through the in-process proxy instead of being bridged into Claude CLI's
+     * `--mcp-config`. Direct bridging causes double execution because both
+     * Claude CLI's own MCP child and opencode hold their own connection to
+     * the same server; routing through the proxy keeps a single execution
+     * site (opencode). Returns null when the feature is disabled, the SDK
+     * client is unavailable, or no MCP servers are configured.
+     */
+    private resolvedProxyMcpTools;
     /**
      * Create a proxy MCP server for a single active Claude process/session.
      * The process lifecycle owns the server lifecycle via session-manager.
@@ -339,6 +365,18 @@ interface BridgedMcp {
     path: string;
     /** Stable hash of the merged opencode mcp block (pre-translation). */
     hash: string;
+    /**
+     * Names of opencode MCP servers that were bridged into Claude CLI's
+     * `--mcp-config`. Excludes any servers passed in `excludeServers`.
+     */
+    serverNames: string[];
+    /**
+     * Names of every enabled opencode MCP server after merge + runtime
+     * overlay, regardless of whether they ended up bridged or excluded.
+     * Callers (e.g. the proxy-tool builder) use this to decide which
+     * `<server>_<tool>` IDs in opencode's tool catalog are MCP-origin.
+     */
+    allEnabledServerNames: string[];
 }
 /**
  * Per-server runtime status from opencode's `client.mcp.status()`. Used as
@@ -362,7 +400,7 @@ type RuntimeMcpStatus = Record<string, string>;
  * return its path + a stable hash. Returns null when no enabled MCP servers
  * remain after the merge + overlay.
  */
-declare function bridgeOpencodeMcp(cwd: string, runtimeStatus?: RuntimeMcpStatus): BridgedMcp | null;
+declare function bridgeOpencodeMcp(cwd: string, runtimeStatus?: RuntimeMcpStatus, excludeServers?: ReadonlySet<string>): BridgedMcp | null;
 
 declare const defaultModels: Record<string, OpenCodeModel>;
 

package/dist/index.js

@@ -637,7 +637,7 @@ function mergeMcp(target, source) {
   }
   return out;
 }
-function bridgeOpencodeMcp(cwd, runtimeStatus) {
+function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers) {
   const worktree = detectWorktree(cwd);
   let merged = {};
   merged = mergeMcp(merged, extractMcpBlock(loadGlobalConfig()));
@@ -676,15 +676,37 @@ function bridgeOpencodeMcp(cwd, runtimeStatus) {
       merged[name] = { ...base, enabled: status === "connected" };
     }
   }
+  const allEnabledServerNames = [];
+  for (const [name, spec] of Object.entries(merged)) {
+    if (!spec || typeof spec !== "object") continue;
+    const enabled = spec.enabled;
+    if (enabled === false) continue;
+    allEnabledServerNames.push(name);
+  }
   const servers = {};
+  const bridgedServerNames = [];
   for (const [name, spec] of Object.entries(merged)) {
     if (!spec || typeof spec !== "object") continue;
+    if (excludeServers?.has(name)) continue;
     const translated = translateServer(name, spec);
-    if (translated) servers[name] = translated;
+    if (translated) {
+      servers[name] = translated;
+      bridgedServerNames.push(name);
+    }
+  }
+  const mergedBody = JSON.stringify({ mcpServers: merged }, null, 2);
+  const hash = crypto.createHash("sha256").update(mergedBody).digest("hex").slice(0, 12);
+  if (Object.keys(servers).length === 0) {
+    const allEnabledServersExcluded = excludeServers && allEnabledServerNames.length > 0 && allEnabledServerNames.every((name) => excludeServers.has(name));
+    if (!allEnabledServersExcluded) return null;
+    return {
+      path: "",
+      hash,
+      serverNames: [],
+      allEnabledServerNames
+    };
   }
-  if (Object.keys(servers).length === 0) return null;
   const body = JSON.stringify({ mcpServers: servers }, null, 2);
-  const hash = crypto.createHash("sha256").update(body).digest("hex").slice(0, 12);
   const outPath = path2.join(
     pluginTmpDir(),
     `mcp-${hash}.json`
@@ -702,9 +724,15 @@ function bridgeOpencodeMcp(cwd, runtimeStatus) {
   log.info("bridged opencode MCP config", {
     target: outPath,
     hash,
-    servers: Object.keys(servers)
+    servers: bridgedServerNames,
+    excluded: excludeServers ? Array.from(excludeServers) : []
   });
-  return { path: outPath, hash };
+  return {
+    path: outPath,
+    hash,
+    serverNames: bridgedServerNames,
+    allEnabledServerNames
+  };
 }
 
 // src/runtime-status.ts
@@ -736,6 +764,35 @@ async function getRuntimeMcpStatus() {
     return void 0;
   }
 }
+async function fetchOpencodeToolList(provider, model, directory) {
+  const client = opencodeClient;
+  if (!client?.tool?.list) return void 0;
+  try {
+    const res = await client.tool.list({
+      query: { provider, model, ...directory ? { directory } : {} }
+    });
+    const data = res.data;
+    if (!Array.isArray(data)) return void 0;
+    const out = [];
+    for (const entry of data) {
+      if (!entry || typeof entry !== "object") continue;
+      const e = entry;
+      const id = typeof e.id === "string" ? e.id : null;
+      const description = typeof e.description === "string" ? e.description : "";
+      const parameters = e.parameters && typeof e.parameters === "object" ? e.parameters : {};
+      if (!id) continue;
+      out.push({ id, description, parameters });
+    }
+    return out;
+  } catch (err) {
+    log.warn("failed to fetch opencode tool list", {
+      provider,
+      model,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return void 0;
+  }
+}
 
 // src/session-manager.ts
 import { spawn } from "child_process";
@@ -1264,6 +1321,7 @@ function writeJson(res, body) {
 import { EventEmitter as EventEmitter3 } from "events";
 var pendingBySession = /* @__PURE__ */ new Map();
 var emitter = new EventEmitter3();
+var PENDING_PROXY_CALL_TIMEOUT_MS = 10 * 60 * 1e3;
 function eventName(sessionKey2) {
   return `pending:${sessionKey2}`;
 }
@@ -1275,16 +1333,50 @@ function onPendingProxyCall(sessionKey2, 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(`Another proxy tool call is already pending for ${sessionKey2}`)
+      new Error(
+        `Stale proxy tool call expired after ${PENDING_PROXY_CALL_TIMEOUT_MS}ms for ${sessionKey2}`
+      )
     );
     pendingBySession.delete(sessionKey2);
   }
+  const timer = setTimeout(() => {
+    const current = pendingBySession.get(sessionKey2);
+    if (!current || current.toolCallId !== call.id) return;
+    pendingBySession.delete(sessionKey2);
+    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,
+      toolCallId: call.id,
+      toolName: call.toolName,
+      timeoutMs: PENDING_PROXY_CALL_TIMEOUT_MS
+    });
+  }, PENDING_PROXY_CALL_TIMEOUT_MS);
   const pending = {
     sessionKey: sessionKey2,
     toolCallId: call.id,
     toolName: call.toolName,
     input: call.input,
+    createdAt: Date.now(),
+    timer,
     resolve: call.resolve,
     reject: call.reject
   };
@@ -1304,6 +1396,7 @@ function resolvePendingProxyCall(sessionKey2, result) {
   const pending = pendingBySession.get(sessionKey2);
   if (!pending) return false;
   pendingBySession.delete(sessionKey2);
+  clearTimeout(pending.timer);
   pending.resolve(result);
   log.info("resolved pending proxy call", {
     sessionKey: sessionKey2,
@@ -1432,18 +1525,20 @@ var ClaudeCodeLanguageModel = class {
    * provided it overlays opencode's UI-toggled state on top of disk config
    * so `/mcps` toggles propagate without a config file write.
    */
-  effectiveMcpConfig(cwd, proxyConfigPath, runtimeStatus) {
+  effectiveMcpConfig(cwd, proxyConfigPath, runtimeStatus, excludeServers) {
     const paths = Array.isArray(this.config.mcpConfig) ? this.config.mcpConfig.slice() : this.config.mcpConfig ? [this.config.mcpConfig] : [];
     let bridgedHash = null;
+    let allEnabledServerNames = [];
     if (this.config.bridgeOpencodeMcp !== false) {
-      const bridged = bridgeOpencodeMcp(cwd, runtimeStatus);
+      const bridged = bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers);
       if (bridged) {
-        paths.push(bridged.path);
+        if (bridged.path) paths.push(bridged.path);
         bridgedHash = bridged.hash;
+        allEnabledServerNames = bridged.allEnabledServerNames;
       }
     }
     if (proxyConfigPath) paths.push(proxyConfigPath);
-    return { paths, bridgedHash };
+    return { paths, bridgedHash, allEnabledServerNames };
   }
   /** Resolve ProxyToolDef[] for the configured proxyTools names. */
   resolvedProxyTools() {
@@ -1459,6 +1554,45 @@ var ClaudeCodeLanguageModel = class {
     }
     return picked.length > 0 ? picked : null;
   }
+  /**
+   * Resolve ProxyToolDef[] for opencode's MCP-bridged tools so they go
+   * through the in-process proxy instead of being bridged into Claude CLI's
+   * `--mcp-config`. Direct bridging causes double execution because both
+   * Claude CLI's own MCP child and opencode hold their own connection to
+   * the same server; routing through the proxy keeps a single execution
+   * site (opencode). Returns null when the feature is disabled, the SDK
+   * client is unavailable, or no MCP servers are configured.
+   */
+  async resolvedProxyMcpTools(allEnabledServerNames) {
+    if (this.config.proxyOpencodeMcpTools === false) return null;
+    if (this.config.bridgeOpencodeMcp === false) return null;
+    if (allEnabledServerNames.length === 0) return null;
+    const items = await fetchOpencodeToolList(
+      this.config.provider,
+      this.modelId,
+      this.config.cwd
+    );
+    if (!items || items.length === 0) return null;
+    const serversByLengthDesc = [...allEnabledServerNames].sort(
+      (a, b) => b.length - a.length
+    );
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const item of items) {
+      const matchedServer = serversByLengthDesc.find(
+        (name) => item.id === name || item.id.startsWith(`${name}_`)
+      );
+      if (!matchedServer) continue;
+      if (seen.has(item.id)) continue;
+      seen.add(item.id);
+      out.push({
+        name: item.id,
+        description: item.description ?? "",
+        inputSchema: item.parameters && typeof item.parameters === "object" ? item.parameters : { type: "object", properties: {} }
+      });
+    }
+    return out.length > 0 ? out : null;
+  }
   /**
    * Create a proxy MCP server for a single active Claude process/session.
    * The process lifecycle owns the server lifecycle via session-manager.
@@ -1740,7 +1874,7 @@ var ClaudeCodeLanguageModel = class {
     const scope = this.requestScope(options);
     const affinity = this.sessionAffinity(options);
     const sk = sessionKey(cwd, `${this.modelId}::${scope}::${affinity}`);
-    if (scope === "tools" && this.resolvedProxyTools()) {
+    if (scope === "tools" && (this.resolvedProxyTools() || this.config.proxyOpencodeMcpTools !== false && this.config.bridgeOpencodeMcp !== false)) {
       return this.doGenerateViaStream(options);
     }
     if (scope === "no-tools") {
@@ -2137,8 +2271,18 @@ ${plan}
           }
         }
         const setup = async () => {
-          if (!proxyServer && resolvedProxy) {
-            proxyServer = await self.ensureProxyServer(resolvedProxy, sk);
+          const discovery = self.effectiveMcpConfig(
+            cwd,
+            void 0,
+            runtimeStatus
+          );
+          const proxyMcpTools = await self.resolvedProxyMcpTools(
+            discovery.allEnabledServerNames
+          );
+          const excludeServers = proxyMcpTools ? new Set(discovery.allEnabledServerNames) : void 0;
+          const combinedProxyTools = resolvedProxy || proxyMcpTools ? [...resolvedProxy ?? [], ...proxyMcpTools ?? []] : null;
+          if (!proxyServer && combinedProxyTools) {
+            proxyServer = await self.ensureProxyServer(combinedProxyTools, sk);
           }
           const proxyDisallowed = resolvedProxy ? disallowedToolFlags(resolvedProxy) : [];
           const extraDisallowed = [];
@@ -2147,7 +2291,8 @@ ${plan}
           const mcp = self.effectiveMcpConfig(
             cwd,
             proxyServer?.configPath(),
-            runtimeStatus
+            runtimeStatus,
+            excludeServers
           );
           const systemPromptFile = activeProcess ? void 0 : buildAppendedSystemPrompt(cwd);
           const cliArgs = buildCliArgs({
@@ -3225,7 +3370,8 @@ function createClaudeCode(settings = {}) {
       controlRequestDenyMessage: settings.controlRequestDenyMessage,
       proxyTools,
       webSearch: settings.webSearch,
-      hotReloadMcp: settings.hotReloadMcp ?? true
+      hotReloadMcp: settings.hotReloadMcp ?? true,
+      proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true
     });
   };
   const provider = function(modelId) {