@khalilgharbaoui/opencode-claude-code-plugin 0.62.1 → 0.63.1

package/dist/index.js

@@ -2045,6 +2045,10 @@ function clearAccountFailoverQuestions(sessionKey2) {
     if (key.startsWith(prefix)) pendingQuestions2.delete(key);
   }
 }
+function hasAccountFailoverQuestions(sessionKey2) {
+  const prefix = `${sessionKey2}${KEY_SEPARATOR2}`;
+  return [...pendingQuestions2.keys()].some((key) => key.startsWith(prefix));
+}
 function describeReset(resetsAt) {
   return formatResetsAt(resetsAt);
 }
@@ -3164,6 +3168,10 @@ function clearSubagentDispatchQuestions(sessionKey2) {
     if (key.startsWith(prefix)) pending.delete(key);
   }
 }
+function hasPendingSubagentDispatch(sessionKey2) {
+  const prefix = `${sessionKey2}${KEY_SEPARATOR3}`;
+  return [...pending.keys()].some((key) => key.startsWith(prefix));
+}
 function isSubagentDispatchActive(input) {
   if (input.compactionMode) return false;
   if (input.childSession) return false;
@@ -5833,6 +5841,9 @@ function isPendingProxyCallChannelClosed(call) {
 function findPendingProxyCall(toolCallId) {
   return pendingByCallId.get(toolCallId);
 }
+function hasAnyPendingProxyCall() {
+  return pendingByCallId.size > 0;
+}
 function getPendingProxyCalls(sessionKey2) {
   const s = callIdsBySession.get(sessionKey2);
   if (!s || s.size === 0) return [];
@@ -6074,6 +6085,10 @@ function noteExplicitTaskModels(parentSessionId, tasks, now = Date.now()) {
   }
   return noted;
 }
+function hasUnclaimedExplicitTaskModels(now = Date.now()) {
+  pruneClaims2(now);
+  return claims2.length > 0;
+}
 function explicitTaskModelFor(sessionId) {
   return sessionModels.get(sessionId);
 }
@@ -7895,6 +7910,12 @@ function noteRelayMemberServing() {
   ownServed = true;
   join10();
 }
+function relayMemberHasServed() {
+  return ownServed;
+}
+function leaveSessionEventRelay() {
+  leave();
+}
 function openRelayFollower() {
   const state = relayState();
   join10();
@@ -8327,6 +8348,10 @@ function setClaudeSessionId(key, sessionId) {
   capClaudeSessions();
 }
 function deleteClaudeSessionId(key) {
+  forgetClaudeSessionInMemory(key);
+  forgetResumePoint(key);
+}
+function forgetClaudeSessionInMemory(key) {
   clearExitPlanModeQuestions(key);
   clearAccountFailoverQuestions(key);
   clearSubagentDispatchQuestions(key);
@@ -8335,7 +8360,52 @@ function deleteClaudeSessionId(key) {
   claudeSessions.delete(key);
   forgetForkFingerprint(key);
   forgetServedConversation(key);
-  forgetResumePoint(key);
+}
+function keyBelongsToSession(key, sessionID, ap) {
+  return ap?.opencodeSessionID === sessionID || describeSessionKey(key).session === sessionID;
+}
+function keyHeldHere(key) {
+  return claudeSessionIsWriting(key) || hasAccountFailoverQuestions(key) || hasPendingSubagentDispatch(key);
+}
+function sessionHeldHere(sessionID) {
+  if (!sessionID || sessionID === "default") return false;
+  for (const [key, ap] of activeProcesses) {
+    if (keyBelongsToSession(key, sessionID, ap) && keyHeldHere(key)) return true;
+  }
+  for (const key of claudeSessions.keys()) {
+    if (keyBelongsToSession(key, sessionID) && keyHeldHere(key)) return true;
+  }
+  return false;
+}
+function noWorkInFlightHere() {
+  for (const ap of activeProcesses.values()) {
+    if (isTurnInFlight(ap)) return false;
+  }
+  return !hasAnyPendingProxyCall() && !hasUnclaimedExplicitTaskModels();
+}
+function holdsNoClaudeState() {
+  return activeProcesses.size === 0 && claudeSessions.size === 0 && !hasAnyPendingProxyCall();
+}
+async function releaseIdleForHandover(sessionID) {
+  if (sessionID === "default") return [];
+  const belongs = (key, ap) => sessionID === void 0 || keyBelongsToSession(key, sessionID, ap);
+  const released = [];
+  const exits = [];
+  for (const [key, ap] of [...activeProcesses]) {
+    if (!belongs(key, ap) || keyHeldHere(key)) continue;
+    exits.push(deleteActiveProcessAndWait(key));
+    released.push(key);
+  }
+  await Promise.all(exits);
+  for (const key of [...claudeSessions.keys()]) {
+    if (!belongs(key) || keyHeldHere(key)) continue;
+    forgetClaudeSessionInMemory(key);
+    if (!released.includes(key)) released.push(key);
+  }
+  if (released.length > 0) {
+    log.info("handed claude sessions to another copy of the plugin", { sessionID, released });
+  }
+  return released;
 }
 function transferClaudeSession(fromKey, toKey) {
   if (fromKey === toKey) return void 0;
@@ -8359,7 +8429,20 @@ function transferClaudeSession(fromKey, toKey) {
 function effortSessionKey(baseKey, effort) {
   return effort ? `${baseKey}::effort=${effort}` : baseKey;
 }
-function invalidateOtherEffortSessions(baseKey, effort) {
+function spawnIdentity(key) {
+  const parts = key.split("::");
+  if (parts.length > 1 && parts[parts.length - 1].startsWith("effort=")) parts.pop();
+  const last = parts.length - 1;
+  if (parts[last].startsWith("context=")) {
+    try {
+      const context = JSON.parse(parts[last].slice("context=".length));
+      if (Array.isArray(context)) parts[last] = `context=${JSON.stringify(context.slice(0, 2))}`;
+    } catch {
+    }
+  }
+  return parts.join("::");
+}
+function invalidateOtherSpawnVariants(baseKey, effort) {
   const levels = [
     void 0,
     "minimal",
@@ -8369,16 +8452,23 @@ function invalidateOtherEffortSessions(baseKey, effort) {
     "xhigh",
     "max"
   ];
-  const staleKeys = levels.filter((level) => level !== effort).map((level) => effortSessionKey(baseKey, level));
+  const currentKey = effortSessionKey(baseKey, effort);
+  const identity = spawnIdentity(currentKey);
+  const staleKeys = [
+    .../* @__PURE__ */ new Set([
+      ...[...claudeSessions.keys()].reverse(),
+      ...levels.map((level) => effortSessionKey(baseKey, level)),
+      ...activeProcesses.keys()
+    ])
+  ].filter((key) => key !== currentKey && spawnIdentity(key) === identity);
   for (const key of staleKeys) {
     const active = activeProcesses.get(key);
     if (getPendingProxyCalls(key).length || hasExitPlanModeQuestions(key) || active?.pendingProxyCompletions?.size || active && (active.lineEmitter.listenerCount("line") > 0 || isSideQuestionPending(active))) {
       throw new Error(
-        "Cannot change reasoning effort while the previous effort session has pending work. Finish that work at its original effort first."
+        "Cannot change reasoning effort, prompt cache TTL, maxTurns or maxBudgetUsd while this conversation's previous claude process has pending work. Finish that work under its original settings first."
       );
     }
   }
-  const currentKey = effortSessionKey(baseKey, effort);
   for (const key of staleKeys) {
     deleteActiveProcess(key);
     if (transferClaudeSession(key, currentKey)) {
@@ -9166,6 +9256,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "agent maxTurns refused: not a positive whole number",
   "agent model override refused: unknown model",
   "agent prompt cache ttl refused: unknown value",
+  "an older plugin build failed to release its claude sessions",
   "an opencode read deny rule could not be mapped onto Claude's own Read; that path stays readable by the CLI's own file tools",
   "auto-continuation stopped",
   "auto-continuing incomplete claude result",
@@ -9312,6 +9403,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "task_batch resolving with child results missing",
   "the interactive transport has not been measured on this Claude Code version; it reads the TUI's screen and transcript, which a new release can change. If a turn hangs or a dialog is not handled, run /claude-code-doctor bundle and report it",
   "the interactive turn did not take a forwarded user message",
+  "the plugin build chosen for this turn could not take it; running it on this one",
   "this opencode process is running an older plugin build than the one on disk",
   "timed out pending proxy call",
   "turn abort listener threw",
@@ -10017,7 +10109,7 @@ function emptyMapping(enabled) {
 }
 function mapReadRules(rules, options = {}) {
   const deny = [];
-  const ask = [];
+  const ask2 = [];
   const unmapped = [];
   const shadowedAllows = [];
   const seen = /* @__PURE__ */ new Set();
@@ -10025,7 +10117,7 @@ function mapReadRules(rules, options = {}) {
   rules.forEach((rule, index) => {
     if (rule.effect === "ask") {
       if (supersededBy(index, rule.pattern, () => true)) return;
-      if (!ask.includes(rule.pattern)) ask.push(rule.pattern);
+      if (!ask2.includes(rule.pattern)) ask2.push(rule.pattern);
       return;
     }
     if (rule.effect !== "deny") return;
@@ -10046,7 +10138,7 @@ function mapReadRules(rules, options = {}) {
       if (!shadowedAllows.includes(later.pattern)) shadowedAllows.push(later.pattern);
     }
   });
-  return { deny, ask, unmapped, shadowedAllows };
+  return { deny, ask: ask2, unmapped, shadowedAllows };
 }
 function resolveReadRuleMapping(input) {
   if (input.enabled === false) return emptyMapping(false);
@@ -10801,6 +10893,159 @@ import * as fs7 from "fs";
 import * as path10 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
+// src/plugin-copies.ts
+var ROUTED_TURN_LIMIT_MS = 2 * 60 * 6e4;
+var COPIES_KEY = /* @__PURE__ */ Symbol.for("@khalilgharbaoui/opencode-claude-code-plugin/copies/v1");
+function copiesState() {
+  const holder = globalThis;
+  let state = holder[COPIES_KEY];
+  if (!state) {
+    state = { copies: [], active: void 0, switching: void 0, turns: /* @__PURE__ */ new Map() };
+    holder[COPIES_KEY] = state;
+  }
+  return state;
+}
+function routedTurns(state, now) {
+  for (const [token, turn] of state.turns) {
+    if (now - turn.startedAt > ROUTED_TURN_LIMIT_MS) state.turns.delete(token);
+  }
+  return [...state.turns.values()];
+}
+function ask(question, fallback) {
+  try {
+    return question();
+  } catch {
+    return fallback;
+  }
+}
+async function releaseQuietly(copy, sessionID) {
+  try {
+    await copy.release(sessionID);
+  } catch (err) {
+    log.warn("an older plugin build failed to release its claude sessions", {
+      version: copy.version,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function registerPluginCopy(copy) {
+  const state = copiesState();
+  if (state.copies.includes(copy)) return;
+  state.copies.push(copy);
+  state.active ??= copy;
+}
+function unregisterPluginCopy(copy) {
+  const state = copiesState();
+  const index = state.copies.indexOf(copy);
+  if (index !== -1) state.copies.splice(index, 1);
+  if (state.active === copy) state.active = void 0;
+}
+function isActivePluginCopy(copy) {
+  return copiesState().active === copy;
+}
+function processLoadedBuild(build) {
+  return copiesState().copies.some(
+    (copy) => !copy.disposed && copy.version === build.version && copy.build.entryPath === build.entryPath && copy.build.mtimeMs === build.mtimeMs && copy.build.size === build.size
+  );
+}
+function switchWhenQuiet(state, now) {
+  if (state.switching) return;
+  const newest = [...state.copies].reverse().find((copy) => !copy.disposed);
+  if (!newest || newest === state.active) return;
+  const others = state.copies.filter((copy) => copy !== newest);
+  const busy = new Set(routedTurns(state, now).map((turn) => turn.copy));
+  if (!others.every((copy) => !busy.has(copy) && ask(() => copy.quiet(), false))) return;
+  const previous = state.active;
+  state.active = newest;
+  log.info("switched to the newest plugin build", {
+    from: previous?.version,
+    to: newest.version
+  });
+  state.switching = Promise.all(others.map((copy) => releaseQuietly(copy))).then(() => {
+    state.switching = void 0;
+  });
+}
+function servingCopy(state, sessionID, own) {
+  if (sessionID) {
+    const holder = state.copies.find((copy) => ask(() => copy.holds(sessionID), false));
+    if (holder) return holder;
+  }
+  return state.active ?? own;
+}
+function followStream(source, end) {
+  const reader = source.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          end();
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (err) {
+        end();
+        controller.error(err);
+      }
+    },
+    async cancel(reason) {
+      end();
+      await reader.cancel(reason);
+    }
+  });
+}
+function untilTurnEnds(result, end) {
+  const stream = result?.stream;
+  if (!(stream instanceof ReadableStream)) {
+    end();
+    return result;
+  }
+  return { ...result, stream: followStream(stream, end) };
+}
+async function routeTurn(input) {
+  const state = copiesState();
+  if (state.copies.length === 0) return input.runHere();
+  const now = input.now ?? Date.now;
+  if (state.switching) await state.switching;
+  switchWhenQuiet(state, now());
+  if (state.switching) await state.switching;
+  const sessionID = input.sessionID && input.sessionID !== "default" ? input.sessionID : void 0;
+  const target = servingCopy(state, sessionID, input.own);
+  const token = {};
+  state.turns.set(token, { copy: target, sessionID, startedAt: now() });
+  let ended = false;
+  const end = () => {
+    if (ended) return;
+    ended = true;
+    state.turns.delete(token);
+  };
+  try {
+    if (sessionID) {
+      await Promise.all(
+        state.copies.filter((copy) => copy !== target).map((copy) => releaseQuietly(copy, sessionID))
+      );
+    }
+    if (target === input.own) return untilTurnEnds(await input.runHere(), end);
+    let model;
+    try {
+      model = await target.modelFor(input.turn);
+    } catch (err) {
+      log.warn("the plugin build chosen for this turn could not take it; running it on this one", {
+        version: target.version,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      const turn = state.turns.get(token);
+      if (turn) turn.copy = input.own;
+      return untilTurnEnds(await input.runHere(), end);
+    }
+    return untilTurnEnds(await input.runOn(model), end);
+  } catch (err) {
+    end();
+    throw err;
+  }
+}
+
 // src/startup-diagnostics.ts
 import { execFile as execFile3 } from "child_process";
 import * as fs6 from "fs";
@@ -11065,6 +11310,8 @@ function createStaleBuildWatch(io) {
   const warned = /* @__PURE__ */ new Set();
   let checkedAt;
   let cached2 = null;
+  let cachedOnDisk;
+  const loadedHere = (onDisk) => onDisk !== void 0 && io.loadedElsewhere?.(onDisk) === true;
   const read = () => {
     let onDisk;
     try {
@@ -11082,18 +11329,21 @@ function createStaleBuildWatch(io) {
     },
     check() {
       const now = io.now();
-      if (checkedAt !== void 0 && now - checkedAt < throttleMs) return cached2;
+      if (checkedAt !== void 0 && now - checkedAt < throttleMs) {
+        return cached2 && !loadedHere(cachedOnDisk) ? cached2 : null;
+      }
       checkedAt = now;
       const status = read();
-      cached2 = status.stale;
-      if (status.stale && status.onDisk) {
-        const identity = `${status.stale.kind}:${status.onDisk.version}:${status.onDisk.mtimeMs}:${status.onDisk.size}`;
+      cachedOnDisk = status.onDisk;
+      cached2 = status.stale && loadedHere(status.onDisk) ? null : status.stale;
+      if (cached2 && status.onDisk) {
+        const identity = `${cached2.kind}:${status.onDisk.version}:${status.onDisk.mtimeMs}:${status.onDisk.size}`;
         if (!warned.has(identity)) {
           warned.add(identity);
           warn({
-            kind: status.stale.kind,
-            loadedVersion: status.stale.loadedVersion,
-            onDiskVersion: status.stale.onDiskVersion,
+            kind: cached2.kind,
+            loadedVersion: cached2.loadedVersion,
+            onDiskVersion: cached2.onDiskVersion,
             path: io.loaded.entryPath
           });
         }
@@ -11152,7 +11402,8 @@ function staleBuildWatch() {
     watch = createStaleBuildWatch({
       loaded,
       readOnDisk: () => readOnDiskBuild(loaded.entryPath),
-      now: () => Date.now()
+      now: () => Date.now(),
+      loadedElsewhere: (onDisk) => processLoadedBuild({ entryPath: loaded.entryPath, ...onDisk })
     });
   }
   return watch;
@@ -18351,7 +18602,7 @@ var ClaudeCodeLanguageModel = class {
         });
       }
     }
-    if (!compactionMode) invalidateOtherEffortSessions(baseKey, reasoningEffort);
+    if (!compactionMode) invalidateOtherSpawnVariants(baseKey, reasoningEffort);
     if (!compactionMode && affinity !== "default") {
       recordSessionSpawn(affinity, {
         model: stripAccountSuffix(failover.modelId),
@@ -20900,9 +21151,97 @@ function handleSessionEventHere(event) {
   const stopped = stoppedSessionIdV2(event);
   if (stopped) releaseParkedProxyCallsForSession(stopped);
 }
+var ownCopy;
+var liveSetups = 0;
+var plannedByDirectory = /* @__PURE__ */ new Map();
+var forwardedProviders = /* @__PURE__ */ new Map();
+var MAX_FORWARDED_PROVIDERS = 32;
+function plannedSettings(directory, providerID) {
+  const here = plannedByDirectory.get(directory)?.get(providerID);
+  if (here) return here;
+  for (const planned of plannedByDirectory.values()) {
+    const found = planned.get(providerID);
+    if (found) return found;
+  }
+  return void 0;
+}
+function pluginCopyFor(deps) {
+  if (ownCopy) return ownCopy;
+  const loaded = staleBuildWatch().loaded;
+  ownCopy = {
+    id: randomUUID8(),
+    version: loaded.version,
+    build: { entryPath: loaded.entryPath, mtimeMs: loaded.mtimeMs, size: loaded.size },
+    disposed: false,
+    holds: (sessionID) => sessionHeldHere(sessionID),
+    quiet: () => noWorkInFlightHere(),
+    release: (sessionID) => releaseIdleForHandover(sessionID),
+    async modelFor(turn) {
+      const planned = plannedSettings(turn.directory, turn.providerID);
+      if (!planned) throw new Error(`no provider ${turn.providerID} is planned in this build`);
+      const cacheKey = JSON.stringify([turn.directory ?? null, turn.providerID, turn.sdkOptions]);
+      let provider = forwardedProviders.get(cacheKey);
+      if (!provider) {
+        const settings = await resolveSdkSettings(turn.providerID, planned, turn.sdkOptions);
+        provider = deps.createProvider(settings);
+        forwardedProviders.set(cacheKey, provider);
+        while (forwardedProviders.size > MAX_FORWARDED_PROVIDERS) {
+          const oldest = forwardedProviders.keys().next().value;
+          if (oldest === void 0) break;
+          forwardedProviders.delete(oldest);
+        }
+      }
+      return provider.languageModel(turn.modelId);
+    }
+  };
+  return ownCopy;
+}
+function retireWhenSpent() {
+  const copy = ownCopy;
+  if (!copy?.disposed || isActivePluginCopy(copy) || !holdsNoClaudeState()) return;
+  unregisterPluginCopy(copy);
+  leaveSessionEventRelay();
+  log.info("a disposed plugin build left the process", { version: copy.version });
+}
+function routedModel(model, copy, turn) {
+  const sessionOf = (options) => resolveSessionAffinity(
+    options.headers,
+    options.providerOptions,
+    turn.providerID
+  );
+  return {
+    specificationVersion: model.specificationVersion,
+    provider: model.provider,
+    modelId: model.modelId,
+    supportedUrls: model.supportedUrls,
+    doStream: (options) => routeTurn({
+      own: copy,
+      turn,
+      sessionID: sessionOf(options),
+      runHere: () => model.doStream(options),
+      runOn: (other) => other.doStream(options)
+    }),
+    doGenerate: (options) => routeTurn({
+      own: copy,
+      turn,
+      sessionID: sessionOf(options),
+      runHere: () => model.doGenerate(options),
+      runOn: (other) => other.doGenerate(options)
+    })
+  };
+}
+function routedProvider(provider, copy, base) {
+  const languageModel = (modelId) => routedModel(provider.languageModel(modelId), copy, { ...base, modelId });
+  return Object.assign((modelId) => languageModel(modelId), provider, {
+    languageModel
+  });
+}
 var closeOwnFeed;
 defineOwnRelayMember({
-  handle: (event) => handleSessionEventHere(event),
+  handle: (event) => {
+    handleSessionEventHere(event);
+    retireWhenSpent();
+  },
   feedOpened: () => {
     closeOwnFeed ??= openSessionRunEventFeed();
   },
@@ -21015,6 +21354,11 @@ function createV2Setup(deps) {
       }
     }
     const planned = /* @__PURE__ */ new Map();
+    const copy = pluginCopyFor(deps);
+    copy.disposed = false;
+    registerPluginCopy(copy);
+    liveSetups += 1;
+    plannedByDirectory.set(directory, planned);
     registrations.push(
       await ctx.provider.transform((editor) => {
         const seed = editor.get(BASE_PROVIDER_ID);
@@ -21058,7 +21402,11 @@ function createV2Setup(deps) {
         const providerID = event.model.providerID;
         if (!isClaudeCodeProviderId(providerID)) return;
         const settings = await resolveSdkSettings(providerID, planned.get(providerID), event.options);
-        event.sdk = deps.createProvider(settings);
+        event.sdk = routedProvider(deps.createProvider(settings), copy, {
+          directory,
+          providerID,
+          sdkOptions: event.options
+        });
         log.debug("v2 sdk created", { providerID, cliPath: settings.cliPath });
       })
     );
@@ -21125,6 +21473,11 @@ function createV2Setup(deps) {
     });
     return async () => {
       events.abort();
+      liveSetups = Math.max(0, liveSetups - 1);
+      if (liveSetups === 0) {
+        copy.disposed = true;
+        if (!relayMemberHasServed()) unregisterPluginCopy(copy);
+      }
       for (const registration of registrations.splice(0)) {
         await registration.dispose().catch(() => void 0);
       }