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

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

@@ -742,15 +742,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);
 }
@@ -1045,12 +1036,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 +1098,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 +1149,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 +1174,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);
   });
 }
@@ -1684,7 +1675,7 @@ var ClaudeCodeLanguageModel = class {
     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 +1766,7 @@ ${plan}
               durationMs: msg.duration_ms,
               usage: msg.usage
             };
-            resolve2({
+            resolve3({
               ...resultMeta,
               text: responseText,
               thinking: thinkingText,
@@ -1786,7 +1777,7 @@ ${plan}
         }
       });
       rl.on("close", () => {
-        resolve2({
+        resolve3({
           ...resultMeta,
           text: responseText,
           thinking: thinkingText,
@@ -2901,6 +2892,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 readFileSync2,
+  realpathSync,
+  rmSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, 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 ? join3(xdg, "opencode") : null,
+    join3(homedir2(), ".cache", "opencode"),
+    join3(homedir2(), "Library", "Caches", "opencode")
+  ].filter((p) => Boolean(p));
+}
+function userOpencodeJsonPath() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join3(homedir2(), ".config");
+  return join3(xdgConfig, "opencode", "opencode.json");
+}
+function userIntendsToUseUnscoped() {
+  const cfg = userOpencodeJsonPath();
+  if (!existsSync2(cfg)) return false;
+  try {
+    const json = JSON.parse(readFileSync2(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 = join3(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 = join3(stalePath, "package.json");
+  if (!existsSync2(pkgJsonPath)) return;
+  let pkg = {};
+  try {
+    pkg = JSON.parse(readFileSync2(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 = join3(cacheRoot, "package.json");
+  if (!existsSync2(cachePkgJson)) return;
+  try {
+    const cfg = JSON.parse(readFileSync2(cachePkgJson, "utf8"));
+    if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
+      delete cfg.dependencies[STALE_PACKAGE_NAME];
+      writeFileSync3(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 +3182,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);
   }
@@ -3106,11 +3198,10 @@ var server = async (input) => {
         ...await providerConfig(existing)
       };
     },
-    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)