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

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/claude-code-language-model.ts
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 
 // src/ids.ts
 import { randomInt } from "crypto";
@@ -906,6 +906,44 @@ function recordUsageReading(account, window, reading, now = Date.now()) {
   cache = { path: file, usage: kept };
   return writeStore(file, kept, store.known) ? entry : null;
 }
+function usageReadingsFromObservation(observation, previous, now = Date.now()) {
+  const out = [];
+  const windows = observation.windows ?? {};
+  const limiting = observation.window;
+  if (limiting && observation.status) {
+    const own = windows[limiting];
+    out.push([
+      limiting,
+      {
+        utilization: finite(observation.utilization) ? observation.utilization : own && finite(own.utilization) ? own.utilization : null,
+        resetsAt: finite(observation.resetsAt) ? observation.resetsAt : own?.resetsAt,
+        status: observation.status
+      }
+    ]);
+  }
+  for (const [window, own] of Object.entries(windows)) {
+    if (window === limiting || !finite(own.utilization)) continue;
+    const before = previous(window);
+    const stillRefused = before !== void 0 && before.status === "rejected" && isReadingCurrent(before, now) && own.utilization >= 1;
+    out.push([window, { utilization: own.utilization, resetsAt: own.resetsAt, status: stillRefused ? "rejected" : "allowed" }]);
+  }
+  return out;
+}
+function recordRateLimitObservation(account, observation, now = Date.now()) {
+  if (!NAME.test(account)) return false;
+  const file = accountUsageStorePath();
+  const store = parseStore(file, now);
+  const merged = store.usage;
+  const windows = merged.get(account) ?? /* @__PURE__ */ new Map();
+  const previous = (window) => windows.get(window) ?? cached(now).get(account)?.get(window);
+  const readings = usageReadingsFromObservation(observation, previous, now).filter(([window]) => NAME.test(window));
+  if (readings.length === 0) return false;
+  for (const [window, reading] of readings) windows.set(window, applyReading(previous(window), reading, now));
+  merged.set(account, windows);
+  const kept = bounded(merged, now);
+  cache = { path: file, usage: kept };
+  return writeStore(file, kept, store.known);
+}
 function markUsageNoted(account, window, thresholds, now = Date.now()) {
   if (!NAME.test(account) || !NAME.test(window) || thresholds.length === 0) return false;
   const file = accountUsageStorePath();
@@ -992,6 +1030,18 @@ function str(value) {
 function num(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+function parseUnifiedWindows(value) {
+  if (!isRecord(value)) return void 0;
+  const out = {};
+  for (const [window, raw] of Object.entries(value)) {
+    if (!isRecord(raw)) continue;
+    const utilization = num(raw.utilization);
+    if (utilization === void 0 || utilization < 0) continue;
+    const resetsAt = num(raw.resetsAt);
+    out[window] = resetsAt === void 0 ? { utilization } : { utilization, resetsAt };
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 var RATE_LIMIT_MARKER = "\u258C **rate limit:**";
 var RATE_LIMIT_ACTION = "Enable extra usage or add credits on the account, wait for the window to reset, switch account, org or plan, or authenticate with an API key.";
 var OVERAGE_DISABLED_REASONS = {
@@ -1020,6 +1070,7 @@ function parseRateLimitEvent(msg) {
   if (msg.type !== "rate_limit_event") return null;
   const info = msg.rate_limit_info;
   if (!isRecord(info)) return null;
+  const windows = parseUnifiedWindows(info.unifiedWindows);
   return {
     status: str(info.status),
     rateLimitType: str(info.rateLimitType),
@@ -1028,7 +1079,8 @@ function parseRateLimitEvent(msg) {
     isUsingOverage: info.isUsingOverage === true,
     overageStatus: str(info.overageStatus),
     overageResetsAt: num(info.overageResetsAt),
-    overageDisabledReason: str(info.overageDisabledReason)
+    overageDisabledReason: str(info.overageDisabledReason),
+    ...windows ? { windows } : {}
   };
 }
 function resetsAtToMs(resetsAt) {
@@ -7804,6 +7856,71 @@ async function requestSideQuestion(activeProcess, question, options) {
   });
 }
 
+// src/session-event-relay.ts
+var RELAY_KEY = /* @__PURE__ */ Symbol.for("@khalilgharbaoui/opencode-claude-code-plugin/session-event-relay");
+function relayState() {
+  const holder = globalThis;
+  let state = holder[RELAY_KEY];
+  if (!state) {
+    state = { members: /* @__PURE__ */ new Set(), followers: 0 };
+    holder[RELAY_KEY] = state;
+  }
+  return state;
+}
+function safely(action) {
+  try {
+    action();
+  } catch {
+  }
+}
+var ownMember;
+var ownFollowers = 0;
+var ownServed = false;
+function join10() {
+  if (!ownMember) return;
+  const state = relayState();
+  if (state.members.has(ownMember)) return;
+  state.members.add(ownMember);
+  if (state.followers > 0) safely(() => ownMember?.feedOpened());
+}
+function leave() {
+  if (!ownMember) return;
+  if (relayState().members.delete(ownMember)) safely(() => ownMember?.feedClosed());
+}
+function defineOwnRelayMember(member) {
+  ownMember = member;
+  if (ownServed) join10();
+}
+function noteRelayMemberServing() {
+  ownServed = true;
+  join10();
+}
+function openRelayFollower() {
+  const state = relayState();
+  join10();
+  ownFollowers += 1;
+  state.followers += 1;
+  if (state.followers === 1) {
+    for (const member of state.members) safely(() => member.feedOpened());
+  }
+  let closed = false;
+  return () => {
+    if (closed) return;
+    closed = true;
+    ownFollowers = Math.max(0, ownFollowers - 1);
+    state.followers = Math.max(0, state.followers - 1);
+    if (state.followers === 0) {
+      for (const member of state.members) safely(() => member.feedClosed());
+    }
+    if (ownFollowers === 0 && !ownServed) leave();
+  };
+}
+function relaySessionEvent(event) {
+  const members = relayState().members;
+  if (ownMember && !members.has(ownMember)) safely(() => ownMember?.handle(event));
+  for (const member of [...members]) safely(() => member.handle(event));
+}
+
 // src/session-manager.ts
 function findActiveProcessBySessionId(sessionID) {
   let found;
@@ -8030,6 +8147,7 @@ function processBelongsToAnotherAccount(active, cliPath, configDir) {
 function setActiveProcess(key, ap) {
   cancelIdleProcessEviction(key);
   activeProcesses.set(key, ap);
+  noteRelayMemberServing();
 }
 function noteInteractiveProcessExit(sessionKey2, ap, code) {
   if (activeProcesses.get(sessionKey2) !== ap) return;
@@ -8324,8 +8442,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     settleTurn(ap);
     lineEmitter.emit("close");
   });
-  cancelIdleProcessEviction(sessionKey2);
-  activeProcesses.set(sessionKey2, ap);
+  setActiveProcess(sessionKey2, ap);
   proc.on("error", (err) => {
     log.error("claude process error", { sessionKey: sessionKey2, error: err.message });
   });
@@ -10063,20 +10180,20 @@ async function fetchPlanUsage(cliPath, options = {}) {
 // src/turn-history.ts
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync7, renameSync as renameSync6, statSync as statSync6, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir11 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // src/turn-progress-store.ts
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync6, renameSync as renameSync5, statSync as statSync5, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var MAX_TURN_PROGRESS = 64;
 var TURN_PROGRESS_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var TAG = /^[0-9a-f]{8}$/;
 var pathOverride4 = null;
 function turnProgressStorePath() {
   if (pathOverride4) return pathOverride4;
-  const stateRoot = process.env.XDG_STATE_HOME || join10(homedir10(), ".local", "state");
-  return join10(stateRoot, "opencode-claude-code-plugin", "turn-progress.json");
+  const stateRoot = process.env.XDG_STATE_HOME || join11(homedir10(), ".local", "state");
+  return join11(stateRoot, "opencode-claude-code-plugin", "turn-progress.json");
 }
 function isProgress(value) {
   const record = value;
@@ -10106,7 +10223,7 @@ function recordTurnProgress(tag, progress, now = Date.now()) {
   merged.set(tag, { ...record, out: Math.round(record.out) });
   const kept = [...merged.entries()].slice(-MAX_TURN_PROGRESS);
   try {
-    mkdirSync6(join10(file, ".."), { recursive: true, mode: 448 });
+    mkdirSync6(join11(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
     writeFileSync6(tmp, JSON.stringify({ version: 1, turns: Object.fromEntries(kept) }), { mode: 384 });
     renameSync5(tmp, file);
@@ -10124,8 +10241,8 @@ var SESSION_TAG = /^[0-9a-f]{8}$/;
 var pathOverride5 = null;
 function turnHistoryStorePath() {
   if (pathOverride5) return pathOverride5;
-  const stateRoot = process.env.XDG_STATE_HOME || join11(homedir11(), ".local", "state");
-  return join11(stateRoot, "opencode-claude-code-plugin", "turn-history.json");
+  const stateRoot = process.env.XDG_STATE_HOME || join12(homedir11(), ".local", "state");
+  return join12(stateRoot, "opencode-claude-code-plugin", "turn-history.json");
 }
 function turnHistoryKey(agent, model) {
   return `${agent || "main"}/${model}`;
@@ -10309,7 +10426,7 @@ function recordTurnSample(key, sample) {
   merged.set(key, samples);
   const kept = bounded2(merged);
   try {
-    mkdirSync7(join11(file, ".."), { recursive: true, mode: 448 });
+    mkdirSync7(join12(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
     writeFileSync7(tmp, JSON.stringify({ version: 1, turns: Object.fromEntries(kept) }), { mode: 384 });
     renameSync6(tmp, file);
@@ -12733,7 +12850,7 @@ import { EventEmitter as EventEmitter4 } from "events";
 import { randomUUID as randomUUID5 } from "crypto";
 import { existsSync as existsSync4, writeFileSync as writeFileSync9 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 
 // src/claude-session-bun.ts
 import * as os6 from "os";
@@ -13915,7 +14032,7 @@ ${text2}`
 }
 function stageImage(data, extension) {
   try {
-    const file = join16(pluginTmpDir(), `attachment-${randomUUID5()}.${extension}`);
+    const file = join17(pluginTmpDir(), `attachment-${randomUUID5()}.${extension}`);
     writeFileSync9(file, data, { mode: 384, flag: "wx" });
     return file;
   } catch (err) {
@@ -14399,15 +14516,15 @@ function spawnInteractiveProcess(opts) {
 // src/spawn-record-store.ts
 import { mkdirSync as mkdirSync9, readFileSync as readFileSync11, renameSync as renameSync7, statSync as statSync10, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var MAX_SPAWN_RECORDS = 256;
 var SPAWN_RECORD_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 var pathOverride6 = null;
 var lastWritten = /* @__PURE__ */ new Map();
 function spawnRecordStorePath() {
   if (pathOverride6) return pathOverride6;
-  const stateRoot = process.env.XDG_STATE_HOME || join17(homedir14(), ".local", "state");
-  return join17(stateRoot, "opencode-claude-code-plugin", "session-spawns.json");
+  const stateRoot = process.env.XDG_STATE_HOME || join18(homedir14(), ".local", "state");
+  return join18(stateRoot, "opencode-claude-code-plugin", "session-spawns.json");
 }
 function isRecord5(value) {
   const record = value;
@@ -14459,7 +14576,7 @@ ${record.agent ?? ""}`;
   const cutoff = now - SPAWN_RECORD_MAX_AGE_MS;
   const kept = [...merged.entries()].filter(([, entry]) => entry.at >= cutoff).sort((a, b) => a[1].at - b[1].at).slice(-MAX_SPAWN_RECORDS);
   try {
-    mkdirSync9(join17(file, ".."), { recursive: true, mode: 448 });
+    mkdirSync9(join18(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
     writeFileSync10(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
       mode: 384
@@ -14537,7 +14654,7 @@ function dedupe2(dirs) {
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir15 } from "os";
 import { randomUUID as randomUUID7 } from "crypto";
-import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join18 } from "path";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join19 } from "path";
 function readPromptFileIfPresent(path15) {
   try {
     const content = readFileSync12(path15, "utf8").trim();
@@ -14549,7 +14666,7 @@ function readPromptFileIfPresent(path15) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join18(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join19(dir, "AGENTS.md"));
     if (content) return content;
     const parent = dirname6(dir);
     if (parent === dir) return void 0;
@@ -14701,8 +14818,8 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join18(homedir15(), ".config");
-  const globalAgents = readPromptFileIfPresent(join18(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join19(homedir15(), ".config");
+  const globalAgents = readPromptFileIfPresent(join19(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
   const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
@@ -14718,7 +14835,7 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path15 = join18(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
+  const path15 = join19(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
   try {
     writeFileSync11(path15, content, { encoding: "utf8", mode: 384 });
     return path15;
@@ -16544,11 +16661,18 @@ function createLineHandler(state, ctx) {
           };
           rememberAccountLimit(ctx.sourceAccount, state.accountLimitHit);
         }
-        if (info?.rateLimitType && info.status) {
-          recordUsageReading(ctx.usageAccount, info.rateLimitType, {
-            utilization: info.utilization ?? null,
+        if (info) {
+          recordRateLimitObservation(ctx.usageAccount, {
+            window: info.rateLimitType,
+            status: info.status,
+            utilization: info.utilization,
             resetsAt: resetsAtToMs(info.resetsAt),
-            status: info.status
+            windows: info.windows ? Object.fromEntries(
+              Object.entries(info.windows).map(([window, own]) => [
+                window,
+                { utilization: own.utilization, resetsAt: resetsAtToMs(own.resetsAt) }
+              ])
+            ) : void 0
           });
         }
         const note = reportRateLimitEvent(msg);
@@ -18555,7 +18679,7 @@ var ClaudeCodeLanguageModel = class {
     let replayReason = "no-session-for-key";
     if (this.config.resumeAfterRestart !== false && includeHistoryContext && !compactionMode && !forkFromClaudeSessionId && failoverAnswer?.kind !== "switch") {
       const configDir = resolveConfigDir(this.config.configDir);
-      const transcriptPath2 = (id, dir) => join19(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
+      const transcriptPath2 = (id, dir) => join20(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
       const resumePoint = findResumePoint({
         sessionKey: sk,
         prompt: options.prompt,
@@ -20230,7 +20354,7 @@ import {
   writeFileSync as writeFileSync12
 } from "fs";
 import { homedir as homedir16 } from "os";
-import { dirname as dirname7, join as join20, resolve as resolve6 } from "path";
+import { dirname as dirname7, join as join21, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -20238,14 +20362,14 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join20(xdg, "opencode") : null,
-    join20(homedir16(), ".cache", "opencode"),
-    join20(homedir16(), "Library", "Caches", "opencode")
+    xdg ? join21(xdg, "opencode") : null,
+    join21(homedir16(), ".cache", "opencode"),
+    join21(homedir16(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join20(homedir16(), ".config");
-  return join20(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join21(homedir16(), ".config");
+  return join21(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
@@ -20272,15 +20396,15 @@ function ourLoadedDir() {
 function ourVersion(dir) {
   if (!dir) return null;
   try {
-    const pkg = JSON.parse(readFileSync14(join20(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync14(join21(dir, "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
   } catch {
     return null;
   }
 }
 function markerPath() {
-  const stateRoot = process.env.XDG_STATE_HOME ?? join20(homedir16(), ".local", "state");
-  return join20(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
+  const stateRoot = process.env.XDG_STATE_HOME ?? join21(homedir16(), ".local", "state");
+  return join21(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
 }
 function markerVersion() {
   try {
@@ -20329,7 +20453,7 @@ function cleanupStaleUnscopedInstall() {
 }
 function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync5(cacheRoot)) return;
-  const stalePath = join20(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  const stalePath = join21(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
   if (!existsSync5(stalePath)) return;
   let realStalePath = stalePath;
   try {
@@ -20337,7 +20461,7 @@ function cleanupOne(cacheRoot, ourDir) {
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join20(stalePath, "package.json");
+  const pkgJsonPath = join21(stalePath, "package.json");
   if (!existsSync5(pkgJsonPath)) return;
   let pkg = {};
   try {
@@ -20357,7 +20481,7 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join20(cacheRoot, "package.json");
+  const cachePkgJson = join21(cacheRoot, "package.json");
   if (!existsSync5(cachePkgJson)) return;
   try {
     const cfg = JSON.parse(readFileSync14(cachePkgJson, "utf8"));
@@ -20763,22 +20887,37 @@ function stoppedSessionIdV2(event) {
   const id = event.data?.sessionID;
   return typeof id === "string" && id.length > 0 ? id : void 0;
 }
+function handleSessionEventHere(event) {
+  noteSessionRunEvent(event);
+  const deleted = deletedSessionIdV2(event);
+  if (deleted) {
+    const released = deleteActiveProcessesForSession(deleted);
+    if (released.length > 0) {
+      log.info("released claude state for deleted session", { sessionID: deleted, released });
+    }
+    return;
+  }
+  const stopped = stoppedSessionIdV2(event);
+  if (stopped) releaseParkedProxyCallsForSession(stopped);
+}
+var closeOwnFeed;
+defineOwnRelayMember({
+  handle: (event) => handleSessionEventHere(event),
+  feedOpened: () => {
+    closeOwnFeed ??= openSessionRunEventFeed();
+  },
+  feedClosed: () => {
+    const close = closeOwnFeed;
+    closeOwnFeed = void 0;
+    close?.();
+  }
+});
 async function followSessionEvents(subscribe, signal) {
-  const closeFeed = openSessionRunEventFeed();
+  const closeFollower = openRelayFollower();
   try {
     for await (const event of subscribe({ signal })) {
       if (signal.aborted) break;
-      noteSessionRunEvent(event);
-      const deleted = deletedSessionIdV2(event);
-      if (deleted) {
-        const released = deleteActiveProcessesForSession(deleted);
-        if (released.length > 0) {
-          log.info("released claude state for deleted session", { sessionID: deleted, released });
-        }
-        continue;
-      }
-      const stopped = stoppedSessionIdV2(event);
-      if (stopped) releaseParkedProxyCallsForSession(stopped);
+      relaySessionEvent(event);
     }
   } catch (err) {
     if (!signal.aborted) {
@@ -20788,7 +20927,7 @@ async function followSessionEvents(subscribe, signal) {
       );
     }
   } finally {
-    closeFeed();
+    closeFollower();
   }
 }
 var noticeEmitters = /* @__PURE__ */ new Set();