@khalilgharbaoui/opencode-claude-code-plugin 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -90,12 +90,6 @@ type OpenCodeHooks = {
         id: string;
         models?: (provider: OpenCodeProvider) => Promise<Record<string, OpenCodeModel>>;
     };
-    /**
-     * Called for every bus event opencode publishes. We use this to react to
-     * `global.disposed` (fired when opencode invalidates its config — e.g.
-     * after a UI MCP toggle or `updateGlobal`) and evict cached claude
-     * subprocesses so the next turn picks up the fresh config.
-     */
     event?: (input: {
         event: OpenCodeEvent;
     }) => Promise<void>;

package/dist/index.js

@@ -15,6 +15,9 @@ var log = {
   info(msg, data) {
     if (DEBUG) console.error(fmt("INFO", msg, data));
   },
+  notice(msg, data) {
+    console.error(fmt("NOTICE", msg, data));
+  },
   warn(msg, data) {
     if (DEBUG) console.error(fmt("WARN", msg, data));
   },
@@ -711,6 +714,7 @@ async function getRuntimeMcpStatus() {
 import { spawn } from "child_process";
 import { createInterface } from "readline";
 import { EventEmitter } from "events";
+import { unlink } from "fs/promises";
 var activeProcesses = /* @__PURE__ */ new Map();
 var claudeSessions = /* @__PURE__ */ new Map();
 var MAX_ACTIVE_PROCESSES = 16;
@@ -742,15 +746,6 @@ function deleteActiveProcess(key) {
     activeProcesses.delete(key);
   }
 }
-function evictAllSessions(reason) {
-  const count = activeProcesses.size;
-  if (count === 0) return 0;
-  log.info("evicting all claude processes", { reason, count });
-  for (const key of Array.from(activeProcesses.keys())) {
-    deleteActiveProcess(key);
-  }
-  return count;
-}
 function getClaudeSessionId(key) {
   return claudeSessions.get(key);
 }
@@ -760,7 +755,7 @@ function setClaudeSessionId(key, sessionId) {
 function deleteClaudeSessionId(key) {
   claudeSessions.delete(key);
 }
-function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash) {
+function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash, systemPromptFile) {
   evictIfNeeded();
   log.info("spawning new claude process", { cliPath, cliArgs, cwd, sessionKey: sessionKey2 });
   const proc = spawn(cliPath, cliArgs, {
@@ -781,7 +776,8 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     proc,
     lineEmitter,
     proxyServer: proxyServer ?? null,
-    mcpHash
+    mcpHash,
+    systemPromptFile
   };
   activeProcesses.set(sessionKey2, ap);
   proc.on("error", (err) => {
@@ -790,6 +786,10 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
   proc.on("exit", (code, signal) => {
     log.info("claude process exited", { code, signal, sessionKey: sessionKey2 });
     void proxyServer?.close();
+    if (systemPromptFile) {
+      void unlink(systemPromptFile).catch(() => {
+      });
+    }
     activeProcesses.delete(sessionKey2);
     if (code !== 0 && code !== null) {
       log.info("process exited with error, clearing session", {
@@ -821,7 +821,8 @@ function buildCliArgs(opts) {
     permissionMode,
     mcpConfig,
     strictMcpConfig,
-    disallowedTools
+    disallowedTools,
+    appendSystemPromptFile
   } = opts;
   const args = [
     "--output-format",
@@ -855,6 +856,9 @@ function buildCliArgs(opts) {
   if (disallowedTools && disallowedTools.length > 0) {
     args.push("--disallowedTools", ...disallowedTools);
   }
+  if (appendSystemPromptFile) {
+    args.push("--append-system-prompt-file", appendSystemPromptFile);
+  }
   if (skipPermissions) {
     args.push("--dangerously-skip-permissions");
   }
@@ -1045,12 +1049,12 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
           hasInput: input != null
         });
         const result = await new Promise(
-          (resolve2, reject) => {
+          (resolve3, reject) => {
             const entry = {
               id: callId,
               toolName,
               input,
-              resolve: resolve2,
+              resolve: resolve3,
               reject
             };
             pending.set(callId, entry);
@@ -1107,11 +1111,11 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
       }
     }
   });
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     server2.once("error", reject);
     server2.listen(0, "127.0.0.1", () => {
       server2.off("error", reject);
-      resolve2();
+      resolve3();
     });
   });
   const addr = server2.address();
@@ -1158,8 +1162,8 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
         entry.reject(new Error("proxy MCP server closed"));
       }
       pending.clear();
-      await new Promise((resolve2) => {
-        server2.close(() => resolve2());
+      await new Promise((resolve3) => {
+        server2.close(() => resolve3());
       });
     }
   };
@@ -1183,10 +1187,10 @@ function disallowedToolFlags(tools) {
   return out;
 }
 function readBody(req) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -1252,6 +1256,47 @@ 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 { randomUUID as randomUUID2 } from "crypto";
+import { dirname as dirname2, join as join3 } from "path";
+function readPromptFileIfPresent(path4) {
+  try {
+    const content = readFileSync2(path4, "utf8").trim();
+    return content || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function nearestWorkspaceAgentsPrompt(cwd) {
+  let dir = cwd;
+  while (true) {
+    const content = readPromptFileIfPresent(join3(dir, "AGENTS.md"));
+    if (content) return content;
+    const parent = dirname2(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function buildAppendedSystemPrompt(cwd) {
+  const parts = [];
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join3(homedir2(), ".config");
+  const globalAgents = readPromptFileIfPresent(join3(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`);
+  try {
+    writeFileSync3(path4, content, "utf8");
+    return path4;
+  } catch (err) {
+    log.warn("failed to write system prompt file", { error: String(err) });
+    return void 0;
+  }
+}
 var ClaudeCodeLanguageModel = class {
   specificationVersion = "v3";
   modelId;
@@ -1655,6 +1700,7 @@ var ClaudeCodeLanguageModel = class {
       reasoningEffort
     );
     const runtimeStatus = await getRuntimeMcpStatus();
+    const systemPromptFile = buildAppendedSystemPrompt(cwd);
     const cliArgs = buildCliArgs({
       sessionKey: sk,
       skipPermissions: this.config.skipPermissions !== false,
@@ -1663,7 +1709,8 @@ var ClaudeCodeLanguageModel = class {
       permissionMode: this.config.permissionMode,
       mcpConfig: this.effectiveMcpConfig(cwd, void 0, runtimeStatus).paths,
       strictMcpConfig: this.config.strictMcpConfig,
-      disallowedTools: this.config.webSearch === "disabled" ? ["WebSearch"] : void 0
+      disallowedTools: this.config.webSearch === "disabled" ? ["WebSearch"] : void 0,
+      appendSystemPromptFile: systemPromptFile
     });
     log.info("doGenerate starting", {
       cwd,
@@ -1679,12 +1726,18 @@ var ClaudeCodeLanguageModel = class {
       env: { ...process.env, TERM: "xterm-256color" },
       shell: process.platform === "win32"
     });
+    if (systemPromptFile) {
+      proc.on("exit", () => {
+        void unlink2(systemPromptFile).catch(() => {
+        });
+      });
+    }
     const rl = createInterface2({ input: proc.stdout });
     let responseText = "";
     let thinkingText = "";
     let resultMeta = {};
     const toolCalls = [];
-    const result = await new Promise((resolve2, reject) => {
+    const result = await new Promise((resolve3, reject) => {
       rl.on("line", (line) => {
         if (!line.trim()) return;
         try {
@@ -1775,7 +1828,7 @@ ${plan}
               durationMs: msg.duration_ms,
               usage: msg.usage
             };
-            resolve2({
+            resolve3({
               ...resultMeta,
               text: responseText,
               thinking: thinkingText,
@@ -1786,7 +1839,7 @@ ${plan}
         }
       });
       rl.on("close", () => {
-        resolve2({
+        resolve3({
           ...resultMeta,
           text: responseText,
           thinking: thinkingText,
@@ -1977,6 +2030,7 @@ ${plan}
             proxyServer?.configPath(),
             runtimeStatus
           );
+          const systemPromptFile = activeProcess ? void 0 : buildAppendedSystemPrompt(cwd);
           const cliArgs = buildCliArgs({
             sessionKey: sk,
             skipPermissions,
@@ -1984,7 +2038,8 @@ ${plan}
             permissionMode: self.config.permissionMode,
             mcpConfig: mcp.paths,
             strictMcpConfig: self.config.strictMcpConfig,
-            disallowedTools: allDisallowed.length > 0 ? allDisallowed : void 0
+            disallowedTools: allDisallowed.length > 0 ? allDisallowed : void 0,
+            appendSystemPromptFile: systemPromptFile
           });
           if (activeProcess) {
             proc = activeProcess.proc;
@@ -1997,7 +2052,8 @@ ${plan}
               cwd,
               sk,
               proxyServer,
-              mcp.bridgedHash
+              mcp.bridgedHash,
+              systemPromptFile
             );
             proc = ap.proc;
             lineEmitter = ap.lineEmitter;
@@ -2901,6 +2957,117 @@ function titleizeAccount(account) {
   return normalizeAccountName(account).split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 }
 
+// src/cleanup-stale.ts
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync3,
+  realpathSync,
+  rmSync,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
+var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
+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")
+  ].filter((p) => Boolean(p));
+}
+function userOpencodeJsonPath() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join4(homedir3(), ".config");
+  return join4(xdgConfig, "opencode", "opencode.json");
+}
+function userIntendsToUseUnscoped() {
+  const cfg = userOpencodeJsonPath();
+  if (!existsSync2(cfg)) return false;
+  try {
+    const json = JSON.parse(readFileSync3(cfg, "utf8"));
+    const plugins = json.plugin;
+    if (!Array.isArray(plugins)) return false;
+    return plugins.some(
+      (entry) => typeof entry === "string" && /^opencode-claude-code-plugin(@[^/]+)?$/.test(entry)
+    );
+  } catch {
+    return false;
+  }
+}
+function ourLoadedDir() {
+  try {
+    const filePath = fileURLToPath(import.meta.url);
+    return realpathSync(resolve2(filePath, "..", ".."));
+  } catch {
+    return null;
+  }
+}
+function cleanupStaleUnscopedInstall() {
+  if (alreadyRan) return;
+  alreadyRan = true;
+  if (process.env.OPENCODE_CLAUDE_CODE_PLUGIN_NO_CLEANUP === "1") return;
+  if (userIntendsToUseUnscoped()) return;
+  const ourDir = ourLoadedDir();
+  for (const cacheRoot of candidateCacheRoots()) {
+    try {
+      cleanupOne(cacheRoot, ourDir);
+    } catch (err) {
+      log.warn("cleanup-stale: error processing cache root", {
+        cacheRoot,
+        error: String(err)
+      });
+    }
+  }
+}
+function cleanupOne(cacheRoot, ourDir) {
+  if (!existsSync2(cacheRoot)) return;
+  const stalePath = join4(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  if (!existsSync2(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;
+  let pkg = {};
+  try {
+    pkg = JSON.parse(readFileSync3(pkgJsonPath, "utf8"));
+  } catch {
+    return;
+  }
+  if (pkg.name !== STALE_PACKAGE_NAME) return;
+  if (!pkg.description?.includes(SUSPECT_DESCRIPTION_TOKEN)) return;
+  log.info("cleanup-stale: removing unscoped install", { stalePath });
+  try {
+    rmSync(stalePath, { recursive: true, force: true });
+  } catch (err) {
+    log.warn("cleanup-stale: rmSync failed", {
+      stalePath,
+      error: String(err)
+    });
+    return;
+  }
+  const cachePkgJson = join4(cacheRoot, "package.json");
+  if (!existsSync2(cachePkgJson)) return;
+  try {
+    const cfg = JSON.parse(readFileSync3(cachePkgJson, "utf8"));
+    if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
+      delete cfg.dependencies[STALE_PACKAGE_NAME];
+      writeFileSync4(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
+      log.info("cleanup-stale: pruned dep from cache package.json");
+    }
+  } catch (err) {
+    log.warn("cleanup-stale: cache package.json update failed", {
+      error: String(err)
+    });
+  }
+}
+
 // src/index.ts
 function createClaudeCode(settings = {}) {
   const cliPath = settings.cliPath ?? process.env.CLAUDE_CLI_PATH ?? "claude";
@@ -3080,18 +3247,8 @@ async function expandAccountProviders(config) {
   }
   return expandedCount > 0;
 }
-function readEventType(ev) {
-  if (!ev || typeof ev !== "object") return void 0;
-  const e = ev;
-  if (typeof e.type === "string") return e.type;
-  const payload = e.payload;
-  if (payload && typeof payload === "object") {
-    const t = payload.type;
-    if (typeof t === "string") return t;
-  }
-  return void 0;
-}
 var server = async (input) => {
+  cleanupStaleUnscopedInstall();
   if (input && typeof input === "object" && "client" in input) {
     setOpencodeClient(input.client);
   }
@@ -3099,18 +3256,25 @@ var server = async (input) => {
     config: async (config) => {
       config.provider ??= {};
       const expanded = await expandAccountProviders(config);
-      if (expanded) return;
+      if (expanded) {
+        const registered = Object.entries(config.provider).filter(([id]) => id === PROVIDER_ID2 || id.startsWith(`${PROVIDER_ID2}-`)).map(([id, p]) => ({ id, name: p?.name ?? id }));
+        log.notice("registered claude-code providers", { providers: registered });
+        return;
+      }
       const existing = config.provider[PROVIDER_ID2];
       config.provider[PROVIDER_ID2] = {
         ...existing,
         ...await providerConfig(existing)
       };
+      log.notice("registered claude-code provider", {
+        id: PROVIDER_ID2,
+        name: config.provider[PROVIDER_ID2]?.name ?? PROVIDER_ID2
+      });
     },
-    event: async ({ event }) => {
-      if (readEventType(event) === "global.disposed") {
-        evictAllSessions("global.disposed");
-      }
-    },
+    // No `event` hook: MCP config drift is detected at turn start by the
+    // hot-reload check in `claude-code-language-model.ts`, which respawns
+    // claude safely between turns. Eviction on `global.disposed` would kill
+    // an in-flight stream and abort the user's current turn.
     provider: {
       id: PROVIDER_ID2,
       models: async (provider) => defaultModelsForProvider(provider.models)