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

package/README.md

@@ -311,7 +311,7 @@ Set `permissionMode: "plan"` to forward `--permission-mode plan` to Claude. The
 
 - **Empty text blocks are dropped.** Claude sometimes opens a `content_block_start` for text but never sends a delta. The plugin no longer emits the empty block (which was triggering Anthropic 400s like `cache_control cannot be set for empty text blocks`).
 - **`AskUserQuestion`** from the CLI is converted into plain text content rather than forwarded as a tool call.
-- **Result fallback timer.** If the CLI finishes a text block but never sends a `result` message, the stream closes gracefully after 5 seconds rather than hanging.
+- **Wire-inactivity watchdog.** Once the CLI has produced any content, the stream closes gracefully if stdout goes silent for 60 seconds without a `result` message arriving. Resets on every line received, so long mid-turn pauses (Sonnet between text-end and the next tool_use, for example) are tolerated. On a user-initiated abort, the watchdog shortens to 5 seconds.
 - **Per-iteration usage.** When the CLI internally retries with tools, the plugin only counts the last iteration's usage so opencode's context accounting stays accurate.
 - **Lazy `cwd`.** The working directory is re-resolved at every request, so opencode's project-aware behavior works without restarting the plugin.
 - **Variants survive merge.** opencode recalculates variant lists after the plugin loads; the plugin re-injects defaults into runtime config so your variants don't disappear.

package/dist/index.js

@@ -19,7 +19,7 @@ var log = {
     console.error(fmt("NOTICE", msg, data));
   },
   warn(msg, data) {
-    if (DEBUG) console.error(fmt("WARN", msg, data));
+    console.error(fmt("WARN", msg, data));
   },
   error(msg, data) {
     console.error(fmt("ERROR", msg, data));
@@ -381,22 +381,49 @@ Now continuing with the current message:
 }
 
 // src/mcp-bridge.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+import * as crypto from "crypto";
+
+// src/tmp.ts
 import * as fs from "fs";
-import * as path from "path";
 import * as os from "os";
-import * as crypto from "crypto";
+import * as path from "path";
+var PLUGIN_TMP_DIR = path.join(
+  os.tmpdir(),
+  `opencode-claude-code-${process.pid}`
+);
+var registered = false;
+function pluginTmpDir() {
+  if (!fs.existsSync(PLUGIN_TMP_DIR)) {
+    fs.mkdirSync(PLUGIN_TMP_DIR, { recursive: true });
+  }
+  if (!registered) {
+    registered = true;
+    process.on("exit", () => {
+      try {
+        fs.rmSync(PLUGIN_TMP_DIR, { recursive: true, force: true });
+      } catch {
+      }
+    });
+  }
+  return PLUGIN_TMP_DIR;
+}
+
+// src/mcp-bridge.ts
 var FILE_NAMES = ["opencode.jsonc", "opencode.json", "config.json"];
 var PROJECT_FILE_NAMES = ["opencode.json", "opencode.jsonc"];
 function fileExists(p) {
   try {
-    return fs.statSync(p).isFile();
+    return fs2.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function dirExists(p) {
   try {
-    return fs.statSync(p).isDirectory();
+    return fs2.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -442,7 +469,7 @@ function stripJsonComments(text) {
 }
 function readAndParse(file) {
   try {
-    const raw = fs.readFileSync(file, "utf8");
+    const raw = fs2.readFileSync(file, "utf8");
     return JSON.parse(stripJsonComments(raw));
   } catch (e) {
     log.warn("failed to parse opencode config", {
@@ -470,14 +497,14 @@ function deepMerge(target, source) {
 }
 function walkUp(opts) {
   const out = [];
-  let current = path.resolve(opts.start);
+  let current = path2.resolve(opts.start);
   while (true) {
     for (const target of opts.targets) {
-      const candidate = path.join(current, target);
+      const candidate = path2.join(current, target);
       if (opts.predicate(candidate)) out.push(candidate);
     }
-    if (opts.stop && current === path.resolve(opts.stop)) break;
-    const parent = path.dirname(current);
+    if (opts.stop && current === path2.resolve(opts.stop)) break;
+    const parent = path2.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -485,28 +512,28 @@ function walkUp(opts) {
 }
 function detectWorktree(cwd) {
   const override = process.env.OPENCODE_WORKTREE;
-  if (override) return path.resolve(override);
-  let current = path.resolve(cwd);
+  if (override) return path2.resolve(override);
+  let current = path2.resolve(cwd);
   while (true) {
-    const gitPath = path.join(current, ".git");
+    const gitPath = path2.join(current, ".git");
     try {
-      if (fs.existsSync(gitPath)) return current;
+      if (fs2.existsSync(gitPath)) return current;
     } catch {
     }
-    const parent = path.dirname(current);
+    const parent = path2.dirname(current);
     if (parent === current) return void 0;
     current = parent;
   }
 }
 function globalConfigDir() {
-  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
-  return path.join(xdg, "opencode");
+  const xdg = process.env.XDG_CONFIG_HOME ?? path2.join(os2.homedir(), ".config");
+  return path2.join(xdg, "opencode");
 }
 function loadGlobalConfig() {
   const dir = globalConfigDir();
   let merged = {};
   for (const name of FILE_NAMES.slice().reverse()) {
-    const file = path.join(dir, name);
+    const file = path2.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = deepMerge(merged, parsed);
@@ -516,7 +543,7 @@ function loadGlobalConfig() {
 function loadProjectFilesInDir(dir) {
   let merged = {};
   for (const name of PROJECT_FILE_NAMES) {
-    const file = path.join(dir, name);
+    const file = path2.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = deepMerge(merged, parsed);
@@ -527,7 +554,7 @@ function dotOpencodeDirs(cwd, worktree) {
   const dirs = [];
   const seen = /* @__PURE__ */ new Set();
   const push = (p) => {
-    const abs = path.resolve(p);
+    const abs = path2.resolve(p);
     if (!seen.has(abs) && dirExists(abs)) {
       seen.add(abs);
       dirs.push(abs);
@@ -541,9 +568,9 @@ function dotOpencodeDirs(cwd, worktree) {
   })) {
     push(dir);
   }
-  const home = os.homedir();
+  const home = os2.homedir();
   if (home) {
-    const homeDot = path.join(home, ".opencode");
+    const homeDot = path2.join(home, ".opencode");
     if (dirExists(homeDot)) push(homeDot);
   }
   const envDir = process.env.OPENCODE_CONFIG_DIR;
@@ -628,7 +655,7 @@ function bridgeOpencodeMcp(cwd, runtimeStatus) {
   const projectDirs = [];
   const seenProjectDirs = /* @__PURE__ */ new Set();
   for (const f of projectFiles) {
-    const d = path.dirname(f);
+    const d = path2.dirname(f);
     if (!seenProjectDirs.has(d)) {
       seenProjectDirs.add(d);
       projectDirs.push(d);
@@ -658,13 +685,13 @@ function bridgeOpencodeMcp(cwd, runtimeStatus) {
   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 = path.join(
-    os.tmpdir(),
-    `opencode-claude-code-mcp-${hash}.json`
+  const outPath = path2.join(
+    pluginTmpDir(),
+    `mcp-${hash}.json`
   );
   try {
     if (!fileExists(outPath)) {
-      fs.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
+      fs2.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
     }
   } catch (e) {
     log.warn("failed to write bridged MCP config", {
@@ -872,14 +899,14 @@ function sessionKey(cwd, modelId) {
 
 // src/proxy-mcp.ts
 import { createServer } from "http";
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os2 from "os";
+import * as fs3 from "fs";
+import * as path3 from "path";
 import * as crypto2 from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
 var PROTOCOL_VERSION = "2024-11-05";
 var SERVER_NAME = "opencode_proxy";
 var PROXY_TOOL_PREFIX = `mcp__${SERVER_NAME}__`;
+var PROXY_CALL_TIMEOUT_MS = 10 * 60 * 1e3;
 var DEFAULT_PROXY_TOOLS = [
   {
     name: "bash",
@@ -1050,6 +1077,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
           toolName,
           hasInput: input != null
         });
+        let timer = null;
         const result = await new Promise(
           (resolve3, reject) => {
             const entry = {
@@ -1060,9 +1088,24 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
               reject
             };
             pending.set(callId, entry);
+            timer = setTimeout(() => {
+              if (!pending.has(callId)) return;
+              pending.delete(callId);
+              log.warn("proxy-mcp tool call timed out", {
+                callId,
+                toolName,
+                timeoutMs: PROXY_CALL_TIMEOUT_MS
+              });
+              reject(
+                new Error(
+                  `Proxy tool '${toolName}' timed out after ${PROXY_CALL_TIMEOUT_MS}ms waiting for opencode to resolve the call`
+                )
+              );
+            }, PROXY_CALL_TIMEOUT_MS);
             calls.emit("call", entry);
           }
         ).finally(() => {
+          if (timer) clearTimeout(timer);
           pending.delete(callId);
         });
         if (result.kind === "error") {
@@ -1151,11 +1194,11 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
         2
       );
       const hash = crypto2.createHash("sha256").update(body).digest("hex").slice(0, 12);
-      const outPath = path2.join(
-        os2.tmpdir(),
-        `opencode-claude-code-proxy-${hash}.json`
+      const outPath = path3.join(
+        pluginTmpDir(),
+        `proxy-${hash}.json`
       );
-      fs2.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
+      fs3.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
       configFilePath = outPath;
       return outPath;
     },
@@ -1167,6 +1210,13 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
       await new Promise((resolve3) => {
         server2.close(() => resolve3());
       });
+      if (configFilePath) {
+        try {
+          fs3.unlinkSync(configFilePath);
+        } catch {
+        }
+        configFilePath = null;
+      }
     }
   };
   return api;
@@ -1266,9 +1316,9 @@ function resolvePendingProxyCall(sessionKey2, result) {
 // src/claude-code-language-model.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import { homedir as homedir2, tmpdir as tmpdir3 } from "os";
+import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
 import { randomUUID as randomUUID2 } from "crypto";
-import { dirname as dirname2, join as join3 } from "path";
+import { dirname as dirname2, join as join4 } from "path";
 function hasNewUserContent(prompt) {
   for (let i = prompt.length - 1; i >= 0; i--) {
     const msg = prompt[i];
@@ -1283,14 +1333,15 @@ function hasNewUserContent(prompt) {
       for (const part of content) {
         if (part.type === "text" && part.text && part.text.trim()) return true;
         if (part.type === "tool-result") return true;
+        if (part.type === "image" || part.type === "file") return true;
       }
     }
   }
   return false;
 }
-function readPromptFileIfPresent(path4) {
+function readPromptFileIfPresent(path5) {
   try {
-    const content = readFileSync2(path4, "utf8").trim();
+    const content = readFileSync2(path5, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -1299,7 +1350,7 @@ function readPromptFileIfPresent(path4) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join3(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join4(dir, "AGENTS.md"));
     if (content) return content;
     const parent = dirname2(dir);
     if (parent === dir) return void 0;
@@ -1308,17 +1359,17 @@ function nearestWorkspaceAgentsPrompt(cwd) {
 }
 function buildAppendedSystemPrompt(cwd) {
   const parts = [];
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join3(homedir2(), ".config");
-  const globalAgents = readPromptFileIfPresent(join3(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join4(homedir2(), ".config");
+  const globalAgents = readPromptFileIfPresent(join4(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   if (globalAgents) parts.push(globalAgents);
   if (workspaceAgents && workspaceAgents !== globalAgents) parts.push(workspaceAgents);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path4 = join3(tmpdir3(), `opencode-cc-sys-${randomUUID2()}.md`);
+  const path5 = join4(tmpdir2(), `opencode-cc-sys-${randomUUID2()}.md`);
   try {
-    writeFileSync3(path4, content, "utf8");
-    return path4;
+    writeFileSync3(path5, content, "utf8");
+    return path5;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -2889,7 +2940,7 @@ var defaultModels = {
 
 // src/accounts.ts
 import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 var BASE_PROVIDER_ID = "claude-code";
 var DEFAULT_ACCOUNT = "default";
 var SHARED_CAPABILITY_ITEMS = [
@@ -2927,7 +2978,7 @@ function expandHome(value) {
   const home = process.env.HOME ?? process.env.USERPROFILE;
   if (value === "~") return home ?? value;
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return home ? path3.join(home, value.slice(2)) : value;
+    return home ? path4.join(home, value.slice(2)) : value;
   }
   return value;
 }
@@ -2959,8 +3010,8 @@ async function ensureSharedCapabilities(targetRoot) {
   }
 }
 async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
-  const source = path3.join(sourceRoot, item);
-  const target = path3.join(targetRoot, item);
+  const source = path4.join(sourceRoot, item);
+  const target = path4.join(targetRoot, item);
   let sourceStat;
   try {
     sourceStat = await lstat(source);
@@ -2971,8 +3022,8 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
     const targetStat = await lstat(target);
     if (targetStat.isSymbolicLink()) {
       const current = await readlink(target);
-      const resolvedCurrent = path3.resolve(path3.dirname(target), current);
-      const resolvedSource = path3.resolve(source);
+      const resolvedCurrent = path4.resolve(path4.dirname(target), current);
+      const resolvedSource = path4.resolve(source);
       if (resolvedCurrent === resolvedSource) return;
     }
     log.warn("shared Claude capability already exists; leaving untouched", {
@@ -2987,11 +3038,11 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
   await symlink(source, target, type);
 }
 async function writeAccountWrapper(account, baseCliPath, configDir) {
-  const cacheRoot = path3.join(
+  const cacheRoot = path4.join(
     process.env.XDG_CACHE_HOME ?? expandHome("~/.cache"),
     "opencode-claude-code-plugin"
   );
-  const wrapperPath = path3.join(cacheRoot, `claude-${account}`);
+  const wrapperPath = path4.join(cacheRoot, `claude-${account}`);
   const suffix = `@${account}`;
   await mkdir(cacheRoot, { recursive: true });
   const script = `#!/usr/bin/env bash
@@ -3031,14 +3082,14 @@ function titleizeAccount(account) {
 
 // src/cleanup-stale.ts
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   readFileSync as readFileSync3,
   realpathSync,
-  rmSync,
+  rmSync as rmSync2,
   writeFileSync as writeFileSync4
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join4, resolve as resolve2 } from "path";
+import { join as join5, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -3046,18 +3097,18 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join4(xdg, "opencode") : null,
-    join4(homedir3(), ".cache", "opencode"),
-    join4(homedir3(), "Library", "Caches", "opencode")
+    xdg ? join5(xdg, "opencode") : null,
+    join5(homedir3(), ".cache", "opencode"),
+    join5(homedir3(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join4(homedir3(), ".config");
-  return join4(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join5(homedir3(), ".config");
+  return join5(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
-  if (!existsSync2(cfg)) return false;
+  if (!existsSync3(cfg)) return false;
   try {
     const json = JSON.parse(readFileSync3(cfg, "utf8"));
     const plugins = json.plugin;
@@ -3095,17 +3146,17 @@ function cleanupStaleUnscopedInstall() {
   }
 }
 function cleanupOne(cacheRoot, ourDir) {
-  if (!existsSync2(cacheRoot)) return;
-  const stalePath = join4(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
-  if (!existsSync2(stalePath)) return;
+  if (!existsSync3(cacheRoot)) return;
+  const stalePath = join5(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  if (!existsSync3(stalePath)) return;
   let realStalePath = stalePath;
   try {
     realStalePath = realpathSync(stalePath);
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join4(stalePath, "package.json");
-  if (!existsSync2(pkgJsonPath)) return;
+  const pkgJsonPath = join5(stalePath, "package.json");
+  if (!existsSync3(pkgJsonPath)) return;
   let pkg = {};
   try {
     pkg = JSON.parse(readFileSync3(pkgJsonPath, "utf8"));
@@ -3116,7 +3167,7 @@ function cleanupOne(cacheRoot, ourDir) {
   if (!pkg.description?.includes(SUSPECT_DESCRIPTION_TOKEN)) return;
   log.info("cleanup-stale: removing unscoped install", { stalePath });
   try {
-    rmSync(stalePath, { recursive: true, force: true });
+    rmSync2(stalePath, { recursive: true, force: true });
   } catch (err) {
     log.warn("cleanup-stale: rmSync failed", {
       stalePath,
@@ -3124,8 +3175,8 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join4(cacheRoot, "package.json");
-  if (!existsSync2(cachePkgJson)) return;
+  const cachePkgJson = join5(cacheRoot, "package.json");
+  if (!existsSync3(cachePkgJson)) return;
   try {
     const cfg = JSON.parse(readFileSync3(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
@@ -3342,12 +3393,12 @@ var server = async (input) => {
       config.provider ??= {};
       const expanded = await expandAccountProviders(config);
       if (expanded) {
-        const registered = Object.entries(config.provider).filter(([id]) => id === PROVIDER_ID2 || id.startsWith(`${PROVIDER_ID2}-`)).map(([id, p]) => ({
+        const registered2 = Object.entries(config.provider).filter(([id]) => id === PROVIDER_ID2 || id.startsWith(`${PROVIDER_ID2}-`)).map(([id, p]) => ({
           id,
           name: p?.name ?? id,
           cwd: p?.options?.cwd
         }));
-        log.notice("registered claude-code providers", { providers: registered });
+        log.notice("registered claude-code providers", { providers: registered2 });
         return;
       }
       const existing = config.provider[PROVIDER_ID2];