very-happy-cli 0.2.165 → 0.2.167

package/dist/precheckCompat-CWOi5c9L.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+const PRECHECK_UNSUPPORTED_SERVER_MESSAGE = "This server does not support automation prechecks: it would drop the precheck and run the action every time. Upgrade the server, or create the automation without a precheck.";
+function serverStoresPrecheck(automation) {
+  return Object.prototype.hasOwnProperty.call(automation, "precheck");
+}
+async function createAutomationChecked(client, input) {
+  if (!input.precheck) return client.create(input);
+  const created = await client.create({ ...input, status: "paused" });
+  if (!serverStoresPrecheck(created)) {
+    const removed = await client.remove(created.id).then(() => true, () => false);
+    throw new Error(removed ? PRECHECK_UNSUPPORTED_SERVER_MESSAGE : `${PRECHECK_UNSUPPORTED_SERVER_MESSAGE} The automation "${created.name}" was left paused; delete it.`);
+  }
+  if (input.status === "paused") return created;
+  try {
+    return await client.resume(created.id);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`Automation "${created.name}" (id ${created.id}) was created paused, with its precheck, but could not be resumed: ${reason} Resume it (very-happy auto resume ${created.name}) or delete it.`);
+  }
+}
+async function updateAutomationChecked(client, id, input) {
+  const updated = await client.update(id, input);
+  if (input.precheck && !serverStoresPrecheck(updated)) throw new Error(`${PRECHECK_UNSUPPORTED_SERVER_MESSAGE} (Other changes were saved.)`);
+  return updated;
+}
+
+exports.createAutomationChecked = createAutomationChecked;
+exports.updateAutomationChecked = updateAutomationChecked;

package/dist/precheckCompat-DeEbilbr.mjs

@@ -0,0 +1,26 @@
+const PRECHECK_UNSUPPORTED_SERVER_MESSAGE = "This server does not support automation prechecks: it would drop the precheck and run the action every time. Upgrade the server, or create the automation without a precheck.";
+function serverStoresPrecheck(automation) {
+  return Object.prototype.hasOwnProperty.call(automation, "precheck");
+}
+async function createAutomationChecked(client, input) {
+  if (!input.precheck) return client.create(input);
+  const created = await client.create({ ...input, status: "paused" });
+  if (!serverStoresPrecheck(created)) {
+    const removed = await client.remove(created.id).then(() => true, () => false);
+    throw new Error(removed ? PRECHECK_UNSUPPORTED_SERVER_MESSAGE : `${PRECHECK_UNSUPPORTED_SERVER_MESSAGE} The automation "${created.name}" was left paused; delete it.`);
+  }
+  if (input.status === "paused") return created;
+  try {
+    return await client.resume(created.id);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`Automation "${created.name}" (id ${created.id}) was created paused, with its precheck, but could not be resumed: ${reason} Resume it (very-happy auto resume ${created.name}) or delete it.`);
+  }
+}
+async function updateAutomationChecked(client, id, input) {
+  const updated = await client.update(id, input);
+  if (input.precheck && !serverStoresPrecheck(updated)) throw new Error(`${PRECHECK_UNSUPPORTED_SERVER_MESSAGE} (Other changes were saved.)`);
+  return updated;
+}
+
+export { createAutomationChecked as c, updateAutomationChecked as u };

package/dist/rateLimitWindows-CusGIqlq.cjs

@@ -0,0 +1,258 @@
+'use strict';
+
+var logger = require('./logger-B_MWPbZz.cjs');
+
+const MAX_WINDOWS_PER_PROVIDER = 8;
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function round2(value) {
+  return Math.round(value * 100) / 100;
+}
+const RATE_LIMIT_MAX_RESET_AHEAD_MS = 30 * 24 * 60 * 6e4;
+const RATE_LIMIT_NULL_RESET_MAX_AGE_MS = 7 * 24 * 60 * 6e4;
+const RATE_LIMIT_MAX_USED_PERCENT = 1e3;
+function plausibleReset(resetsAt, now) {
+  if (resetsAt === null) return null;
+  return resetsAt - now > RATE_LIMIT_MAX_RESET_AHEAD_MS ? null : resetsAt;
+}
+function epochToMs(value, now) {
+  const n = finite(value);
+  if (n === void 0 || n <= 0) return null;
+  return plausibleReset(n > 1e12 ? Math.round(n) : Math.round(n * 1e3), now);
+}
+function plausiblePercent(percent, source) {
+  if (percent === void 0 || percent < 0) return void 0;
+  if (percent > RATE_LIMIT_MAX_USED_PERCENT) {
+    logger.logger.debug(`[rate-limits] dropped ${source}: ${percent}% is outside the plausible range`);
+    return void 0;
+  }
+  return round2(percent);
+}
+function finiteOrLog(value, source) {
+  const n = finite(value);
+  if (n === void 0 && value !== void 0 && value !== null) {
+    logger.logger.debug(`[rate-limits] dropped ${source}: non-finite value`);
+  }
+  return n;
+}
+const CLAUDE_UNIFIED_KINDS = ["five_hour", "seven_day", "seven_day_overage_included"];
+const CLAUDE_WINDOW_MINUTES = {
+  five_hour: 300,
+  seven_day: 10080,
+  seven_day_opus: 10080,
+  seven_day_sonnet: 10080,
+  seven_day_overage_included: 10080
+};
+function fromClaudeRateLimitInfo(info, now) {
+  if (!info || typeof info !== "object") return null;
+  const raw = info;
+  const windows = /* @__PURE__ */ new Map();
+  const unified = raw.unifiedWindows;
+  if (unified && typeof unified === "object") {
+    for (const kind of CLAUDE_UNIFIED_KINDS) {
+      const w = unified[kind];
+      if (!w || typeof w !== "object") continue;
+      const utilization = finiteOrLog(w.utilization, `claude ${kind}`);
+      const usedPercent = plausiblePercent(utilization === void 0 ? void 0 : utilization * 100, `claude ${kind}`);
+      if (usedPercent === void 0) continue;
+      windows.set(kind, {
+        kind,
+        usedPercent,
+        resetsAt: epochToMs(w.resetsAt, now),
+        windowMinutes: CLAUDE_WINDOW_MINUTES[kind],
+        observedAt: now
+      });
+    }
+  }
+  const status = typeof raw.status === "string" ? raw.status : void 0;
+  const topKind = typeof raw.rateLimitType === "string" ? raw.rateLimitType : void 0;
+  if (topKind && topKind !== "overage") {
+    const utilization = finiteOrLog(raw.utilization, `claude ${topKind}`);
+    const usedPercent = utilization !== void 0 ? plausiblePercent(utilization * 100, `claude ${topKind}`) : status === "rejected" ? 100 : void 0;
+    if (usedPercent !== void 0) {
+      const prior = windows.get(topKind);
+      windows.set(topKind, {
+        kind: topKind,
+        // The limiting window's own number wins only if it is higher —
+        // both describe the same window, the larger is the safer read.
+        usedPercent: prior ? Math.max(prior.usedPercent, usedPercent) : usedPercent,
+        resetsAt: epochToMs(raw.resetsAt, now) ?? prior?.resetsAt ?? null,
+        windowMinutes: CLAUDE_WINDOW_MINUTES[topKind],
+        observedAt: now
+      });
+    }
+  }
+  if (windows.size === 0) return null;
+  return {
+    provider: "claude",
+    observedAt: now,
+    ...status ? { status } : {},
+    windows: [...windows.values()]
+  };
+}
+function codexKind(windowMinutes, fallback) {
+  if (windowMinutes === 300) return "five_hour";
+  if (windowMinutes === 10080) return "seven_day";
+  if (windowMinutes !== void 0) return `window_${windowMinutes}m`;
+  return fallback;
+}
+function fromCodexRateLimits(snapshot, now) {
+  if (!snapshot || typeof snapshot !== "object") return null;
+  const raw = snapshot;
+  const limitId = raw.limitId;
+  if (limitId !== void 0 && limitId !== null && limitId !== "codex") return null;
+  const windows = [];
+  for (const slot of ["primary", "secondary"]) {
+    const w = raw[slot];
+    if (!w || typeof w !== "object") continue;
+    const usedPercent = plausiblePercent(finiteOrLog(w.usedPercent, `codex ${slot}`), `codex ${slot}`);
+    if (usedPercent === void 0) continue;
+    const windowMinutes = finite(w.windowDurationMins);
+    windows.push({
+      kind: codexKind(windowMinutes, slot),
+      usedPercent,
+      resetsAt: epochToMs(w.resetsAt, now),
+      ...windowMinutes !== void 0 ? { windowMinutes } : {},
+      observedAt: now
+    });
+  }
+  if (windows.length === 0) return null;
+  return { provider: "codex", observedAt: now, windows };
+}
+function sanitizeWindow(value) {
+  if (!value || typeof value !== "object") return null;
+  const w = value;
+  const kind = typeof w.kind === "string" && w.kind.length > 0 && w.kind.length <= 64 ? w.kind : null;
+  const usedPercent = finite(w.usedPercent);
+  const observedAt = finite(w.observedAt);
+  if (!kind || usedPercent === void 0 || usedPercent < 0 || observedAt === void 0) return null;
+  const resetsAt = w.resetsAt === null ? null : finite(w.resetsAt) ?? null;
+  const windowMinutes = finite(w.windowMinutes);
+  return {
+    kind,
+    usedPercent,
+    resetsAt,
+    ...windowMinutes !== void 0 ? { windowMinutes } : {},
+    observedAt
+  };
+}
+function sanitizeRateLimitReport(value) {
+  if (!value || typeof value !== "object") return null;
+  const r = value;
+  if (r.provider !== "claude" && r.provider !== "codex") return null;
+  const observedAt = finite(r.observedAt);
+  if (observedAt === void 0 || !Array.isArray(r.windows)) return null;
+  const windows = r.windows.map(sanitizeWindow).filter((w) => w !== null).slice(0, MAX_WINDOWS_PER_PROVIDER);
+  if (windows.length === 0) return null;
+  return {
+    provider: r.provider,
+    observedAt,
+    ...typeof r.status === "string" && r.status.length <= 32 ? { status: r.status } : {},
+    windows
+  };
+}
+function isExpired(window, now) {
+  if (window.resetsAt === null) return now - window.observedAt > RATE_LIMIT_NULL_RESET_MAX_AGE_MS;
+  return window.resetsAt <= now;
+}
+function withPlausibleReset(window, now) {
+  const resetsAt = plausibleReset(window.resetsAt, now);
+  return resetsAt === window.resetsAt ? window : { ...window, resetsAt };
+}
+function keepWindow(window, now) {
+  if (window.usedPercent > RATE_LIMIT_MAX_USED_PERCENT) return null;
+  const normalized = withPlausibleReset(window, now);
+  return isExpired(normalized, now) ? null : normalized;
+}
+function keepWindows(windows, now) {
+  return windows.map((w) => keepWindow(w, now)).filter((w) => w !== null);
+}
+function readRateLimitsState(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  if (!raw.providers || typeof raw.providers !== "object") return null;
+  const providers = {};
+  for (const [name, p] of Object.entries(raw.providers)) {
+    if (!p || typeof p !== "object") continue;
+    const observedAt = finite(p.observedAt);
+    const windowsRaw = p.windows;
+    if (observedAt === void 0 || !Array.isArray(windowsRaw)) continue;
+    const windows = windowsRaw.map(sanitizeWindow).filter((w) => w !== null);
+    const status = p.status;
+    providers[name] = { observedAt, ...typeof status === "string" ? { status } : {}, windows };
+  }
+  return { v: 1, updatedAt: finite(raw.updatedAt) ?? 0, providers };
+}
+function mergeRateLimits(current, report, now) {
+  const base = readRateLimitsState(current) ?? { providers: {} };
+  const prior = base.providers[report.provider];
+  const byKind = /* @__PURE__ */ new Map();
+  for (const w of prior?.windows ?? []) byKind.set(w.kind, w);
+  for (const w of report.windows) {
+    const existing = byKind.get(w.kind);
+    if (!existing || w.observedAt >= existing.observedAt) byKind.set(w.kind, w);
+  }
+  const windows = keepWindows([...byKind.values()], now).slice(0, MAX_WINDOWS_PER_PROVIDER);
+  const providers = {};
+  for (const [name, p] of Object.entries(base.providers)) {
+    if (name === report.provider) continue;
+    providers[name] = { ...p, windows: keepWindows(p.windows, now) };
+  }
+  const newer = !prior || report.observedAt >= prior.observedAt;
+  providers[report.provider] = {
+    observedAt: newer ? report.observedAt : prior.observedAt,
+    ...(newer ? report.status : prior?.status) ? { status: newer ? report.status : prior?.status } : {},
+    windows
+  };
+  return { v: 1, updatedAt: now, providers };
+}
+function rateLimitSignature(state) {
+  if (!state) return "";
+  return Object.keys(state.providers).sort().map((name) => {
+    const p = state.providers[name];
+    const windows = [...p.windows].sort((a, b) => a.kind.localeCompare(b.kind)).map((w) => `${w.kind}:${Math.round(w.usedPercent)}:${w.resetsAt === null ? "-" : Math.round(w.resetsAt / 6e4)}`).join(",");
+    return `${name}[${p.status ?? ""}]{${windows}}`;
+  }).join(";");
+}
+function rateLimitReportSignature(report) {
+  return rateLimitSignature({ providers: { [report.provider]: report } });
+}
+const CODEX_RATE_LIMIT_READ_MIN_INTERVAL_MS = 10 * 6e4;
+function shouldReadCodexRateLimits(state) {
+  if (state.unsupported || state.inFlight) return false;
+  return state.lastReadAt === 0 || state.now - state.lastReadAt >= CODEX_RATE_LIMIT_READ_MIN_INTERVAL_MS;
+}
+function isUnsupportedCodexMethodError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  return /\(code=-3260[01]\)/.test(message) || /unknown variant/i.test(message);
+}
+const RATE_LIMIT_OBSERVED_REFRESH_MS = 30 * 6e4;
+function mergeRateLimitReports(current, reports, now) {
+  let merged = readRateLimitsState(current);
+  for (const report of reports) merged = mergeRateLimits(merged, report, now);
+  return merged;
+}
+function planRateLimitWrite(current, reports, now) {
+  if (reports.length === 0) return null;
+  const before = readRateLimitsState(current);
+  const merged = mergeRateLimitReports(current, reports, now);
+  if (!merged) return null;
+  if (rateLimitSignature(merged) !== rateLimitSignature(before)) return merged;
+  for (const report of reports) {
+    const prior = before?.providers[report.provider];
+    const next = merged.providers[report.provider];
+    if (!prior || next && next.observedAt - prior.observedAt >= RATE_LIMIT_OBSERVED_REFRESH_MS) return merged;
+  }
+  return null;
+}
+
+exports.RATE_LIMIT_OBSERVED_REFRESH_MS = RATE_LIMIT_OBSERVED_REFRESH_MS;
+exports.fromClaudeRateLimitInfo = fromClaudeRateLimitInfo;
+exports.fromCodexRateLimits = fromCodexRateLimits;
+exports.isUnsupportedCodexMethodError = isUnsupportedCodexMethodError;
+exports.mergeRateLimitReports = mergeRateLimitReports;
+exports.planRateLimitWrite = planRateLimitWrite;
+exports.rateLimitReportSignature = rateLimitReportSignature;
+exports.sanitizeRateLimitReport = sanitizeRateLimitReport;
+exports.shouldReadCodexRateLimits = shouldReadCodexRateLimits;

package/dist/rateLimitWindows-vZ9Bo7aT.mjs

@@ -0,0 +1,248 @@
+import { l as logger } from './logger-CbBv3q_b.mjs';
+
+const MAX_WINDOWS_PER_PROVIDER = 8;
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function round2(value) {
+  return Math.round(value * 100) / 100;
+}
+const RATE_LIMIT_MAX_RESET_AHEAD_MS = 30 * 24 * 60 * 6e4;
+const RATE_LIMIT_NULL_RESET_MAX_AGE_MS = 7 * 24 * 60 * 6e4;
+const RATE_LIMIT_MAX_USED_PERCENT = 1e3;
+function plausibleReset(resetsAt, now) {
+  if (resetsAt === null) return null;
+  return resetsAt - now > RATE_LIMIT_MAX_RESET_AHEAD_MS ? null : resetsAt;
+}
+function epochToMs(value, now) {
+  const n = finite(value);
+  if (n === void 0 || n <= 0) return null;
+  return plausibleReset(n > 1e12 ? Math.round(n) : Math.round(n * 1e3), now);
+}
+function plausiblePercent(percent, source) {
+  if (percent === void 0 || percent < 0) return void 0;
+  if (percent > RATE_LIMIT_MAX_USED_PERCENT) {
+    logger.debug(`[rate-limits] dropped ${source}: ${percent}% is outside the plausible range`);
+    return void 0;
+  }
+  return round2(percent);
+}
+function finiteOrLog(value, source) {
+  const n = finite(value);
+  if (n === void 0 && value !== void 0 && value !== null) {
+    logger.debug(`[rate-limits] dropped ${source}: non-finite value`);
+  }
+  return n;
+}
+const CLAUDE_UNIFIED_KINDS = ["five_hour", "seven_day", "seven_day_overage_included"];
+const CLAUDE_WINDOW_MINUTES = {
+  five_hour: 300,
+  seven_day: 10080,
+  seven_day_opus: 10080,
+  seven_day_sonnet: 10080,
+  seven_day_overage_included: 10080
+};
+function fromClaudeRateLimitInfo(info, now) {
+  if (!info || typeof info !== "object") return null;
+  const raw = info;
+  const windows = /* @__PURE__ */ new Map();
+  const unified = raw.unifiedWindows;
+  if (unified && typeof unified === "object") {
+    for (const kind of CLAUDE_UNIFIED_KINDS) {
+      const w = unified[kind];
+      if (!w || typeof w !== "object") continue;
+      const utilization = finiteOrLog(w.utilization, `claude ${kind}`);
+      const usedPercent = plausiblePercent(utilization === void 0 ? void 0 : utilization * 100, `claude ${kind}`);
+      if (usedPercent === void 0) continue;
+      windows.set(kind, {
+        kind,
+        usedPercent,
+        resetsAt: epochToMs(w.resetsAt, now),
+        windowMinutes: CLAUDE_WINDOW_MINUTES[kind],
+        observedAt: now
+      });
+    }
+  }
+  const status = typeof raw.status === "string" ? raw.status : void 0;
+  const topKind = typeof raw.rateLimitType === "string" ? raw.rateLimitType : void 0;
+  if (topKind && topKind !== "overage") {
+    const utilization = finiteOrLog(raw.utilization, `claude ${topKind}`);
+    const usedPercent = utilization !== void 0 ? plausiblePercent(utilization * 100, `claude ${topKind}`) : status === "rejected" ? 100 : void 0;
+    if (usedPercent !== void 0) {
+      const prior = windows.get(topKind);
+      windows.set(topKind, {
+        kind: topKind,
+        // The limiting window's own number wins only if it is higher —
+        // both describe the same window, the larger is the safer read.
+        usedPercent: prior ? Math.max(prior.usedPercent, usedPercent) : usedPercent,
+        resetsAt: epochToMs(raw.resetsAt, now) ?? prior?.resetsAt ?? null,
+        windowMinutes: CLAUDE_WINDOW_MINUTES[topKind],
+        observedAt: now
+      });
+    }
+  }
+  if (windows.size === 0) return null;
+  return {
+    provider: "claude",
+    observedAt: now,
+    ...status ? { status } : {},
+    windows: [...windows.values()]
+  };
+}
+function codexKind(windowMinutes, fallback) {
+  if (windowMinutes === 300) return "five_hour";
+  if (windowMinutes === 10080) return "seven_day";
+  if (windowMinutes !== void 0) return `window_${windowMinutes}m`;
+  return fallback;
+}
+function fromCodexRateLimits(snapshot, now) {
+  if (!snapshot || typeof snapshot !== "object") return null;
+  const raw = snapshot;
+  const limitId = raw.limitId;
+  if (limitId !== void 0 && limitId !== null && limitId !== "codex") return null;
+  const windows = [];
+  for (const slot of ["primary", "secondary"]) {
+    const w = raw[slot];
+    if (!w || typeof w !== "object") continue;
+    const usedPercent = plausiblePercent(finiteOrLog(w.usedPercent, `codex ${slot}`), `codex ${slot}`);
+    if (usedPercent === void 0) continue;
+    const windowMinutes = finite(w.windowDurationMins);
+    windows.push({
+      kind: codexKind(windowMinutes, slot),
+      usedPercent,
+      resetsAt: epochToMs(w.resetsAt, now),
+      ...windowMinutes !== void 0 ? { windowMinutes } : {},
+      observedAt: now
+    });
+  }
+  if (windows.length === 0) return null;
+  return { provider: "codex", observedAt: now, windows };
+}
+function sanitizeWindow(value) {
+  if (!value || typeof value !== "object") return null;
+  const w = value;
+  const kind = typeof w.kind === "string" && w.kind.length > 0 && w.kind.length <= 64 ? w.kind : null;
+  const usedPercent = finite(w.usedPercent);
+  const observedAt = finite(w.observedAt);
+  if (!kind || usedPercent === void 0 || usedPercent < 0 || observedAt === void 0) return null;
+  const resetsAt = w.resetsAt === null ? null : finite(w.resetsAt) ?? null;
+  const windowMinutes = finite(w.windowMinutes);
+  return {
+    kind,
+    usedPercent,
+    resetsAt,
+    ...windowMinutes !== void 0 ? { windowMinutes } : {},
+    observedAt
+  };
+}
+function sanitizeRateLimitReport(value) {
+  if (!value || typeof value !== "object") return null;
+  const r = value;
+  if (r.provider !== "claude" && r.provider !== "codex") return null;
+  const observedAt = finite(r.observedAt);
+  if (observedAt === void 0 || !Array.isArray(r.windows)) return null;
+  const windows = r.windows.map(sanitizeWindow).filter((w) => w !== null).slice(0, MAX_WINDOWS_PER_PROVIDER);
+  if (windows.length === 0) return null;
+  return {
+    provider: r.provider,
+    observedAt,
+    ...typeof r.status === "string" && r.status.length <= 32 ? { status: r.status } : {},
+    windows
+  };
+}
+function isExpired(window, now) {
+  if (window.resetsAt === null) return now - window.observedAt > RATE_LIMIT_NULL_RESET_MAX_AGE_MS;
+  return window.resetsAt <= now;
+}
+function withPlausibleReset(window, now) {
+  const resetsAt = plausibleReset(window.resetsAt, now);
+  return resetsAt === window.resetsAt ? window : { ...window, resetsAt };
+}
+function keepWindow(window, now) {
+  if (window.usedPercent > RATE_LIMIT_MAX_USED_PERCENT) return null;
+  const normalized = withPlausibleReset(window, now);
+  return isExpired(normalized, now) ? null : normalized;
+}
+function keepWindows(windows, now) {
+  return windows.map((w) => keepWindow(w, now)).filter((w) => w !== null);
+}
+function readRateLimitsState(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  if (!raw.providers || typeof raw.providers !== "object") return null;
+  const providers = {};
+  for (const [name, p] of Object.entries(raw.providers)) {
+    if (!p || typeof p !== "object") continue;
+    const observedAt = finite(p.observedAt);
+    const windowsRaw = p.windows;
+    if (observedAt === void 0 || !Array.isArray(windowsRaw)) continue;
+    const windows = windowsRaw.map(sanitizeWindow).filter((w) => w !== null);
+    const status = p.status;
+    providers[name] = { observedAt, ...typeof status === "string" ? { status } : {}, windows };
+  }
+  return { v: 1, updatedAt: finite(raw.updatedAt) ?? 0, providers };
+}
+function mergeRateLimits(current, report, now) {
+  const base = readRateLimitsState(current) ?? { providers: {} };
+  const prior = base.providers[report.provider];
+  const byKind = /* @__PURE__ */ new Map();
+  for (const w of prior?.windows ?? []) byKind.set(w.kind, w);
+  for (const w of report.windows) {
+    const existing = byKind.get(w.kind);
+    if (!existing || w.observedAt >= existing.observedAt) byKind.set(w.kind, w);
+  }
+  const windows = keepWindows([...byKind.values()], now).slice(0, MAX_WINDOWS_PER_PROVIDER);
+  const providers = {};
+  for (const [name, p] of Object.entries(base.providers)) {
+    if (name === report.provider) continue;
+    providers[name] = { ...p, windows: keepWindows(p.windows, now) };
+  }
+  const newer = !prior || report.observedAt >= prior.observedAt;
+  providers[report.provider] = {
+    observedAt: newer ? report.observedAt : prior.observedAt,
+    ...(newer ? report.status : prior?.status) ? { status: newer ? report.status : prior?.status } : {},
+    windows
+  };
+  return { v: 1, updatedAt: now, providers };
+}
+function rateLimitSignature(state) {
+  if (!state) return "";
+  return Object.keys(state.providers).sort().map((name) => {
+    const p = state.providers[name];
+    const windows = [...p.windows].sort((a, b) => a.kind.localeCompare(b.kind)).map((w) => `${w.kind}:${Math.round(w.usedPercent)}:${w.resetsAt === null ? "-" : Math.round(w.resetsAt / 6e4)}`).join(",");
+    return `${name}[${p.status ?? ""}]{${windows}}`;
+  }).join(";");
+}
+function rateLimitReportSignature(report) {
+  return rateLimitSignature({ providers: { [report.provider]: report } });
+}
+const CODEX_RATE_LIMIT_READ_MIN_INTERVAL_MS = 10 * 6e4;
+function shouldReadCodexRateLimits(state) {
+  if (state.unsupported || state.inFlight) return false;
+  return state.lastReadAt === 0 || state.now - state.lastReadAt >= CODEX_RATE_LIMIT_READ_MIN_INTERVAL_MS;
+}
+function isUnsupportedCodexMethodError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  return /\(code=-3260[01]\)/.test(message) || /unknown variant/i.test(message);
+}
+const RATE_LIMIT_OBSERVED_REFRESH_MS = 30 * 6e4;
+function mergeRateLimitReports(current, reports, now) {
+  let merged = readRateLimitsState(current);
+  for (const report of reports) merged = mergeRateLimits(merged, report, now);
+  return merged;
+}
+function planRateLimitWrite(current, reports, now) {
+  if (reports.length === 0) return null;
+  const before = readRateLimitsState(current);
+  const merged = mergeRateLimitReports(current, reports, now);
+  if (!merged) return null;
+  if (rateLimitSignature(merged) !== rateLimitSignature(before)) return merged;
+  for (const report of reports) {
+    const prior = before?.providers[report.provider];
+    const next = merged.providers[report.provider];
+    if (!prior || next && next.observedAt - prior.observedAt >= RATE_LIMIT_OBSERVED_REFRESH_MS) return merged;
+  }
+  return null;
+}
+
+export { RATE_LIMIT_OBSERVED_REFRESH_MS as R, fromClaudeRateLimitInfo as a, sanitizeRateLimitReport as b, fromCodexRateLimits as f, isUnsupportedCodexMethodError as i, mergeRateLimitReports as m, planRateLimitWrite as p, rateLimitReportSignature as r, shouldReadCodexRateLimits as s };

package/dist/{registerCommonHandlers-BR0J4g64.mjs → registerCommonHandlers-B0PVff2U.mjs}

@@ -1,4 +1,4 @@
-import { l as logger } from './logger-CknSVkIe.mjs';
+import { l as logger } from './logger-CbBv3q_b.mjs';
 import { spawn as spawn$1, exec } from 'child_process';
 import { promisify } from 'util';
 import { mkdir, writeFile, appendFile, stat, rename, unlink, readdir, readFile } from 'fs/promises';
@@ -7,7 +7,7 @@ import { resolve, join, sep } from 'path';
 import { spawn } from 'cross-spawn';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
 import { platform } from 'os';
-import { c as configuration } from './configuration-L1qcGTFM.mjs';
+import { c as configuration } from './configuration-WspKd2C2.mjs';
 
 function run$1(args, options) {
   const RUNNER_PATH = resolve(join(projectPath(), "scripts", "ripgrep_launcher.cjs"));

package/dist/{registerCommonHandlers--8ds2auE.cjs → registerCommonHandlers-DVYB3iVn.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var logger = require('./logger-D0hkk7Vo.cjs');
+var logger = require('./logger-B_MWPbZz.cjs');
 var child_process = require('child_process');
 var util = require('util');
 var fs = require('fs/promises');
@@ -9,7 +9,7 @@ var path = require('path');
 var spawn = require('cross-spawn');
 var projectPath = require('./projectPath-ChLhdOyt.cjs');
 var os = require('os');
-var configuration = require('./configuration-BE61XNsg.cjs');
+var configuration = require('./configuration-C3piBtxY.cjs');
 
 function run$1(args, options) {
   const RUNNER_PATH = path.resolve(path.join(projectPath.projectPath(), "scripts", "ripgrep_launcher.cjs"));

package/dist/{registerKillSessionHandler-Czz0tdki.mjs → registerKillSessionHandler-BJMHJHXe.mjs}

@@ -1,17 +1,17 @@
-import { l as logger } from './logger-CknSVkIe.mjs';
+import { l as logger } from './logger-CbBv3q_b.mjs';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
-import './attachmentLimits-B8nzhw-i.mjs';
+import './attachmentLimits-CxG3T18E.mjs';
 import 'node:crypto';
 import 'tweetnacl';
-import './configuration-L1qcGTFM.mjs';
-import './index-vVWpCoTr.mjs';
-import './registerCommonHandlers-BR0J4g64.mjs';
+import './configuration-WspKd2C2.mjs';
+import './index-B0HEEYGh.mjs';
+import './registerCommonHandlers-B0PVff2U.mjs';
 import 'os';
 import 'child_process';
 import '@paralleldrive/cuid2';
-import './persistence-DujtUH94.mjs';
+import './persistence-ON0zpHfb.mjs';
 import 'chalk';
 import './types-CkqAACXx.mjs';
 
@@ -342,10 +342,15 @@ function registerKillSessionHandler(rpcHandlerManager, killThisHappy, archiveEve
     terminationStarted = true;
     void killThisHappy();
   };
+  const signalOnce = () => {
+    if (terminationStarted) return;
+    terminationStarted = true;
+    void (options?.onSignal ?? killThisHappy)();
+  };
   archiveEvents.on("archived", terminateOnce);
   if (options?.processSignals) {
-    process.on("SIGTERM", terminateOnce);
-    process.on("SIGINT", terminateOnce);
+    process.on("SIGTERM", signalOnce);
+    process.on("SIGINT", signalOnce);
   }
   rpcHandlerManager.registerHandler("killSession", async () => {
     logger.debug("Kill session request received");
@@ -358,8 +363,8 @@ function registerKillSessionHandler(rpcHandlerManager, killThisHappy, archiveEve
   return () => {
     archiveEvents.off?.("archived", terminateOnce);
     if (options?.processSignals) {
-      process.off("SIGTERM", terminateOnce);
-      process.off("SIGINT", terminateOnce);
+      process.off("SIGTERM", signalOnce);
+      process.off("SIGINT", signalOnce);
     }
   };
 }