@sideboard-ai/core 0.1.198 → 0.1.200

package/dist/{chunk-SYXSSU7G.js → chunk-5XSDGJMP.js}

@@ -2,7 +2,7 @@
 
 import {
   isOrchestratorThread
-} from "./chunk-6YTI2HBG.js";
+} from "./chunk-EWDE54OI.js";
 import {
   applyConnectedTeamToCli,
   brightsyMcpServerName,
@@ -12,12 +12,15 @@ import {
 import {
   loadBrightsyConfig
 } from "./chunk-Y4MIXGPA.js";
+import {
+  httpFetch
+} from "./chunk-VKQGAWHY.js";
 import {
   codexUnattendedGitConfigArgs,
   mergeAgentGitAuthEnv,
   resolveAgentGitAuthEnv,
   resolveCodexGitWritableRoots
-} from "./chunk-DP4TKAMZ.js";
+} from "./chunk-NXM45OS3.js";
 import {
   enrichPathWithNpmGlobalBin,
   isConductorBundledCli,
@@ -35,7 +38,7 @@ import {
   resolveClaudeExecutable,
   unwrapStrippedElectronLaunch,
   wrapElectronAsNodeLaunch
-} from "./chunk-AH6WIBLY.js";
+} from "./chunk-ISV5IFH3.js";
 import {
   appDataDir
 } from "./chunk-EQNRWDLN.js";
@@ -2420,7 +2423,7 @@ var claudeAdapter = {
       );
     }
     const mode = permissionMode(thread);
-    const { isOrchestratorThread: isOrchestratorThread2 } = await import("./global-workspace-SNJ2Z6SL.js");
+    const { isOrchestratorThread: isOrchestratorThread2 } = await import("./global-workspace-VAO3BQP5.js");
     const isOrchestrator = isOrchestratorThread2(thread);
     const injectedServers = await buildInjectedMcpServers({
       includeSideboard: true,
@@ -4122,6 +4125,356 @@ function resolveQuotaFallbackAgent(current, preferred) {
   return ordered.find((a) => a !== current) ?? (current === "cursor" ? "codex" : "cursor");
 }
 
+// src/agents/claude-usage.ts
+var WINDOW_META = {
+  five_hour: {
+    label: "5-hour session",
+    shortLabel: "5h",
+    detail: "Rolling 5-hour limit across all models"
+  },
+  seven_day: {
+    label: "Weekly",
+    shortLabel: "wk",
+    detail: "7-day cap across all models"
+  },
+  seven_day_opus: {
+    label: "Opus",
+    shortLabel: "Opus",
+    detail: "Weekly Opus-only cap"
+  },
+  seven_day_sonnet: {
+    label: "Sonnet",
+    shortLabel: "Sonnet",
+    detail: "Weekly Sonnet-only cap"
+  }
+};
+var WINDOW_ORDER = [
+  "five_hour",
+  "seven_day",
+  "seven_day_opus",
+  "seven_day_sonnet"
+];
+function parseClaudeResetsAt(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const ms = value > 1e12 ? value : value * 1e3;
+    const d = new Date(ms);
+    return Number.isNaN(d.getTime()) ? null : d.toISOString();
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    if (/^\d+(\.\d+)?$/.test(trimmed)) {
+      return parseClaudeResetsAt(Number(trimmed));
+    }
+    const d = new Date(trimmed);
+    return Number.isNaN(d.getTime()) ? null : d.toISOString();
+  }
+  return null;
+}
+function parseClaudeUtilization(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return Math.max(0, Math.min(100, value));
+}
+function windowFromRaw(id, raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const row = raw;
+  const used = parseClaudeUtilization(row.utilization ?? row.used_percentage);
+  if (used == null) return null;
+  const meta = WINDOW_META[id];
+  return {
+    id,
+    label: meta.label,
+    shortLabel: meta.shortLabel,
+    detail: meta.detail,
+    usedPercent: used,
+    remainingPercent: Math.max(0, Math.min(100, 100 - used)),
+    resetsAt: parseClaudeResetsAt(row.resets_at)
+  };
+}
+function extraUsageFromRaw(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const row = raw;
+  const enabled = row.is_enabled === true || row.enabled === true;
+  if (!enabled && row.is_enabled !== false && row.enabled !== false) return void 0;
+  const usedCredits = numberOrUndef(row.used_credits ?? row.used);
+  const monthlyLimit = numberOrUndef(row.monthly_limit);
+  const usedPercent = parseClaudeUtilization(row.utilization) ?? void 0;
+  return {
+    enabled,
+    ...usedCredits != null ? { usedCredits } : {},
+    ...monthlyLimit != null ? { monthlyLimit } : {},
+    ...usedPercent != null ? { usedPercent } : {}
+  };
+}
+function numberOrUndef(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  return value;
+}
+function parseClaudeUsagePayload(raw, fetchedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  const source = obj.rate_limits && typeof obj.rate_limits === "object" ? obj.rate_limits : obj;
+  const windows = [];
+  for (const id of WINDOW_ORDER) {
+    const parsed = windowFromRaw(id, source[id]);
+    if (parsed) windows.push(parsed);
+  }
+  if (windows.length === 0) return null;
+  const extra = extraUsageFromRaw(obj.extra_usage ?? source.extra_usage);
+  return {
+    windows,
+    ...extra ? { extraUsage: extra } : {},
+    fetchedAt
+  };
+}
+function hottestClaudeWindow(usage) {
+  if (usage.windows.length === 0) return null;
+  return usage.windows.reduce((a, b) => b.usedPercent > a.usedPercent ? b : a);
+}
+function formatClaudeUsageReset(resetsAt, now = /* @__PURE__ */ new Date()) {
+  if (!resetsAt) return "";
+  const at = new Date(resetsAt);
+  if (Number.isNaN(at.getTime())) return "";
+  const ms = at.getTime() - now.getTime();
+  if (ms <= 0) return "resets soon";
+  const minutes = Math.round(ms / 6e4);
+  if (minutes < 60) return `resets in ${Math.max(1, minutes)}m`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 36) return `resets in ${hours}h`;
+  try {
+    return `resets ${at.toLocaleString(void 0, {
+      weekday: "short",
+      hour: "numeric",
+      minute: "2-digit"
+    })}`;
+  } catch {
+    return `resets ${at.toISOString()}`;
+  }
+}
+function formatClaudeUsageResetClock(resetsAt) {
+  if (!resetsAt) return "";
+  const at = new Date(resetsAt);
+  if (Number.isNaN(at.getTime())) return "";
+  try {
+    return at.toLocaleString(void 0, {
+      weekday: "short",
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit"
+    });
+  } catch {
+    return at.toISOString();
+  }
+}
+function formatClaudeUsageFetchedAt(fetchedAt, now = /* @__PURE__ */ new Date()) {
+  const at = new Date(fetchedAt);
+  if (Number.isNaN(at.getTime())) return "";
+  const minutes = Math.max(0, Math.round((now.getTime() - at.getTime()) / 6e4));
+  if (minutes < 1) return "Updated just now";
+  if (minutes < 60) return `Updated ${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 36) return `Updated ${hours}h ago`;
+  return `Updated ${formatClaudeUsageResetClock(fetchedAt)}`;
+}
+function formatClaudeExtraUsageDetail(extra) {
+  if (!extra.enabled) return "Extra usage off";
+  const bits = ["Extra usage on"];
+  if (extra.usedCredits != null && extra.monthlyLimit != null) {
+    bits.push(`${extra.usedCredits} / ${extra.monthlyLimit} credits this month`);
+  } else if (extra.usedCredits != null) {
+    bits.push(`${extra.usedCredits} credits used`);
+  }
+  if (extra.usedPercent != null) {
+    bits.push(`${Math.round(extra.usedPercent)}% of extra pool`);
+  }
+  return bits.join(" \xB7 ");
+}
+function formatClaudeUsageWindowLine(window, now = /* @__PURE__ */ new Date()) {
+  const reset = formatClaudeUsageReset(window.resetsAt, now);
+  const clock = formatClaudeUsageResetClock(window.resetsAt);
+  const left = `${Math.round(window.remainingPercent)}% left`;
+  const used = `${Math.round(window.usedPercent)}% used`;
+  const resetBit = reset ? clock && !reset.includes(clock) ? `${reset} (${clock})` : reset : "";
+  return resetBit ? `${window.label} \u2014 ${window.detail}. ${left} \xB7 ${used} \xB7 ${resetBit}` : `${window.label} \u2014 ${window.detail}. ${left} \xB7 ${used}`;
+}
+function formatClaudeUsageTooltip(usage, now = /* @__PURE__ */ new Date()) {
+  const lines = [
+    "Claude Code plan",
+    ...usage.windows.map((w) => formatClaudeUsageWindowLine(w, now))
+  ];
+  if (usage.extraUsage) {
+    lines.push(formatClaudeExtraUsageDetail(usage.extraUsage));
+  }
+  const fetched = formatClaudeUsageFetchedAt(usage.fetchedAt, now);
+  if (fetched) lines.push(fetched);
+  return lines.join("\n");
+}
+function formatClaudeUsageCompact(window) {
+  return `${window.shortLabel} ${Math.round(window.remainingPercent)}%`;
+}
+function claudeUsageWindowOverLimit(window) {
+  return window.remainingPercent <= 0 || window.usedPercent >= 100;
+}
+function claudeUsageOverLimitWindows(usage) {
+  if (!usage) return [];
+  return usage.windows.filter(claudeUsageWindowOverLimit);
+}
+function formatOverLimitWindowList(windows, now) {
+  const parts = windows.map((w) => {
+    const reset = formatClaudeUsageReset(w.resetsAt, now);
+    return reset ? `${w.label} (${reset})` : w.label;
+  });
+  return {
+    list: parts.join(", "),
+    verb: windows.length === 1 ? "is" : "are"
+  };
+}
+function formatClaudeUsageOverLimitConfirm(windows, now = /* @__PURE__ */ new Date()) {
+  if (windows.length === 0) return "";
+  const { list, verb } = formatOverLimitWindowList(windows, now);
+  return `Claude Code ${list} ${verb} at or over the plan limit. Send this message anyway?`;
+}
+function formatClaudeUsageOverLimitWait(windows, now = /* @__PURE__ */ new Date()) {
+  if (windows.length === 0) return "";
+  const { list, verb } = formatOverLimitWindowList(windows, now);
+  return `Claude Code ${list} ${verb} at or over the plan limit. Sending is paused until the window resets.`;
+}
+
+// src/agents/claude-usage-client.ts
+import { existsSync as existsSync13, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join10 } from "path";
+var CLAUDE_OAUTH_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+var CLAUDE_USAGE_TTL_MS = 9e4;
+var CLAUDE_USAGE_ERROR_TTL_MS = 5 * 6e4;
+var CLAUDE_USAGE_STALE_OK_MS = 30 * 6e4;
+var KEYCHAIN_SERVICES = ["Claude Code-credentials", "Claude Code"];
+var cache = null;
+var errorUntil = 0;
+var inflight = null;
+var lastGood = null;
+var claudeVersion = null;
+function accessTokenFromCredentialsJson(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("sk-ant-")) {
+    const token = trimmed.split(/\s+/)[0];
+    return token || null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    const oauth = parsed.claudeAiOauth && typeof parsed.claudeAiOauth === "object" ? parsed.claudeAiOauth : parsed;
+    const token = oauth.accessToken ?? oauth.access_token;
+    return typeof token === "string" && token.trim() ? token.trim() : null;
+  } catch {
+    return null;
+  }
+}
+function claudeCredentialsPath() {
+  const root = process.env.CLAUDE_CONFIG_DIR?.trim() || join10(homedir5(), ".claude");
+  return join10(root, ".credentials.json");
+}
+async function readFileAccessToken() {
+  const path = claudeCredentialsPath();
+  if (!existsSync13(path)) return null;
+  try {
+    return accessTokenFromCredentialsJson(readFileSync5(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function readKeychainAccessToken() {
+  if (process.platform !== "darwin") return null;
+  for (const service of KEYCHAIN_SERVICES) {
+    const result = await run("security", ["find-generic-password", "-s", service, "-w"], {
+      reject: false,
+      timeoutMs: 4e3
+    });
+    if (result.exitCode !== 0 || !result.stdout.trim()) continue;
+    const token = accessTokenFromCredentialsJson(result.stdout);
+    if (token) return token;
+  }
+  return null;
+}
+async function readClaudeAccessToken() {
+  const envToken = process.env.CLAUDE_CODE_OAUTH_TOKEN?.trim();
+  if (envToken) return envToken;
+  const fromFile = await readFileAccessToken();
+  if (fromFile) return fromFile;
+  return readKeychainAccessToken();
+}
+async function resolveClaudeUserAgent() {
+  if (claudeVersion) return `claude-code/${claudeVersion}`;
+  try {
+    const claude = resolveClaudeExecutable();
+    const result = await run(claude, ["--version"], { reject: false, timeoutMs: 4e3 });
+    const match = `${result.stdout}
+${result.stderr}`.match(/(\d+\.\d+\.\d+)/);
+    claudeVersion = match?.[1] ?? "2.1.80";
+  } catch {
+    claudeVersion = "2.1.80";
+  }
+  return `claude-code/${claudeVersion}`;
+}
+function staleOk(now) {
+  if (!lastGood) return null;
+  if (now - lastGood.at > CLAUDE_USAGE_STALE_OK_MS) return null;
+  return lastGood.value;
+}
+async function getClaudePlanUsage(opts = {}) {
+  const now = opts.now ?? Date.now();
+  if (!opts.force) {
+    if (cache && now - cache.at < CLAUDE_USAGE_TTL_MS) return cache.value;
+    if (now < errorUntil) return staleOk(now);
+  }
+  if (inflight) return inflight;
+  inflight = (async () => {
+    try {
+      const token = await (opts.readAccessToken ?? readClaudeAccessToken)();
+      if (!token) {
+        cache = { at: now, value: null };
+        return null;
+      }
+      const fetchFn = opts.fetch ?? httpFetch;
+      const userAgent = opts.userAgent ?? await resolveClaudeUserAgent();
+      const ac = new AbortController();
+      const timer = setTimeout(() => ac.abort(), 8e3);
+      let res;
+      try {
+        res = await fetchFn(CLAUDE_OAUTH_USAGE_URL, {
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "anthropic-beta": "oauth-2025-04-20",
+            "User-Agent": userAgent
+          },
+          signal: ac.signal
+        });
+      } finally {
+        clearTimeout(timer);
+      }
+      if (res.status === 401 || res.status === 403) {
+        cache = { at: now, value: null };
+        return null;
+      }
+      if (!res.ok) {
+        errorUntil = now + CLAUDE_USAGE_ERROR_TTL_MS;
+        return staleOk(now);
+      }
+      const usage = parseClaudeUsagePayload(await res.json(), new Date(now).toISOString());
+      cache = { at: now, value: usage };
+      if (usage) lastGood = { at: now, value: usage };
+      return usage;
+    } catch {
+      errorUntil = now + CLAUDE_USAGE_ERROR_TTL_MS;
+      return staleOk(now);
+    } finally {
+      inflight = null;
+    }
+  })();
+  return inflight;
+}
+
 // src/agents/install.ts
 var SETUP = {
   claude: {
@@ -4426,6 +4779,18 @@ export {
   isSessionQuotaLimit,
   parseSessionQuotaResetAt,
   resolveQuotaFallbackAgent,
+  parseClaudeUsagePayload,
+  hottestClaudeWindow,
+  formatClaudeUsageReset,
+  formatClaudeUsageResetClock,
+  formatClaudeUsageFetchedAt,
+  formatClaudeExtraUsageDetail,
+  formatClaudeUsageTooltip,
+  formatClaudeUsageCompact,
+  claudeUsageOverLimitWindows,
+  formatClaudeUsageOverLimitConfirm,
+  formatClaudeUsageOverLimitWait,
+  getClaudePlanUsage,
   getAgentSetupInfo,
   listAgentSetupInfo,
   resolveLoginCommand,