@songsid/agend 2.1.1-beta.11 → 2.1.1-beta.12

package/dist/ui/view.html

@@ -83,6 +83,27 @@
   .help-panel li { font-size: 13px; margin: 6px 0; color: var(--fg); }
   .help-panel .close { position: absolute; top: 14px; right: 16px; cursor: pointer; color: var(--dim); font-size: 22px; line-height: 1; background: none; border: none; }
 
+  /* AI usage panel (shares .help-panel chrome) */
+  .u-provider { margin: 14px 0 4px; padding-top: 10px; border-top: 1px solid var(--border); }
+  .u-provider:first-of-type { border-top: none; padding-top: 0; }
+  .u-head { display: flex; align-items: baseline; gap: 8px; }
+  .u-head .u-name { font-size: 14px; font-weight: 600; }
+  .u-head .u-plan { color: var(--dim); font-size: 11px; }
+  .u-metric { margin: 8px 0; }
+  .u-row { display: flex; align-items: baseline; gap: 6px; font-size: 12px; }
+  .u-row .u-label { color: var(--dim); flex: 1; min-width: 0; }
+  .u-row .u-val { font-variant-numeric: tabular-nums; }
+  .u-row .u-status { font-size: 11px; font-weight: 600; }
+  .u-status.warn { color: #d29922; } .u-status.crit { color: #f85149; }
+  .u-meter { height: 6px; background: var(--border); border-radius: 3px; overflow: hidden; margin-top: 4px; }
+  .u-fill { height: 100%; border-radius: 3px; background: var(--accent); min-width: 2px; }
+  .u-fill.warn { background: #d29922; } .u-fill.crit { background: #f85149; }
+  .u-sub { color: var(--dim); font-size: 11px; margin-top: 2px; font-variant-numeric: tabular-nums; }
+  .u-err { color: #d29922; font-size: 12px; margin: 6px 0; }
+  .u-foot { color: var(--dim); font-size: 11px; margin-top: 14px; display: flex; gap: 8px; align-items: baseline; }
+  .u-foot button { background: none; border: 1px solid var(--border); border-radius: 5px; color: var(--dim); cursor: pointer; font-size: 11px; padding: 2px 8px; }
+  .u-foot button:hover { color: var(--fg); border-color: var(--accent); }
+
   #densityBtn { font-size: 14px; font-weight: 600; letter-spacing: -.5px; }
   @media (max-width: 700px) {
     #sidebar { width: 180px; flex-basis: 180px; }
@@ -93,6 +114,7 @@
 </style>
 </head>
 <body>
+  <button class="help-btn" id="usageBtn" title="AI usage" style="right:140px; display:none">📊</button>
   <button class="help-btn" id="densityBtn" title="Font density" style="right:98px">⤢</button>
   <button class="help-btn" id="langBtn" title="Language" style="right:56px">🌐</button>
   <button class="help-btn" id="helpBtn" title="Help">ℹ️</button>
@@ -101,6 +123,10 @@
     <button class="close" id="helpClose" title="Close">×</button>
     <div id="helpContent"></div>
   </aside>
+  <aside class="help-panel" id="usagePanel">
+    <button class="close" id="usageClose" title="Close">×</button>
+    <div id="usageContent"></div>
+  </aside>
   <div id="sidebar"><h1 data-i18n="viewTitle">AgEnD · View</h1><div id="list"></div></div>
   <div id="main">
     <div id="term"><pre id="pre"></pre></div>
@@ -147,7 +173,10 @@
       help2: "Click a group header ▼/▶ to collapse/expand", help3: "✏️ Edit changes display name, role, description",
       help4: "Drag to reorder (needs web.token permission)",
       help5: "Click ⤢ to cycle font density: Fit → Comfortable → Compact",
-      densityFit: "Fit", densityComfortable: "Comfortable", densityCompact: "Compact", densityLabel: "Font density" },
+      densityFit: "Fit", densityComfortable: "Comfortable", densityCompact: "Compact", densityLabel: "Font density",
+      usageTitle: "📊 AI Usage", usageEmpty: "No AI CLI logins found on this machine.",
+      usageUpdated: "updated", usageRefresh: "Refresh", usageHigh: "high", usageNear: "near limit",
+      usageResets: "resets in {t}", usageSoon: "resets soon", usageFail: "Could not load usage data." },
     "zh-TW": { viewTitle: "AgEnD · 檢視", editProfile: "✏️ 編輯", save: "儲存", cancel: "取消",
       displayName: "顯示名稱", role: "角色", description: "描述", tokenPh: "web.token（儲存時需要）",
       saveHint: "檢視為公開（唯讀）。儲存需要 web.token（~/.agend/web.token）。", helpTitle: "📖 使用說明",
@@ -155,7 +184,10 @@
       help2: "點 group header ▼/▶ 收合/展開", help3: "✏️ Edit 可修改顯示名稱、角色、描述",
       help4: "拖曳可調整順序（需 web.token 權限）",
       help5: "點 ⤢ 循環切換字級密度：剛好填滿 → 舒適 → 精簡",
-      densityFit: "剛好填滿", densityComfortable: "舒適", densityCompact: "精簡", densityLabel: "字級密度" },
+      densityFit: "剛好填滿", densityComfortable: "舒適", densityCompact: "精簡", densityLabel: "字級密度",
+      usageTitle: "📊 AI 訂閱用量", usageEmpty: "本機沒有偵測到已登入的 AI CLI。",
+      usageUpdated: "更新於", usageRefresh: "重新整理", usageHigh: "偏高", usageNear: "接近上限",
+      usageResets: "{t} 後重置", usageSoon: "即將重置", usageFail: "無法載入用量資料。" },
   };
   let lang = localStorage.getItem("agend_lang") || (navigator.language && navigator.language.toLowerCase().startsWith("zh") ? "zh-TW" : "en");
   if (!I18N[lang]) lang = "en";
@@ -667,6 +699,86 @@
   q("densityBtn").onclick = cycleDensity;
   window.addEventListener("keydown", (e) => { if (e.key === "Escape") setHelp(false); });
 
+  // ── AI usage panel ────────────────────────────────────
+  let usageData = null;
+  let usageTimer = null;
+
+  function usageResetText(iso) {
+    if (!iso) return "";
+    const ms = new Date(iso).getTime() - Date.now();
+    if (isNaN(ms)) return "";
+    if (ms <= 0) return T("usageSoon");
+    const h = Math.floor(ms / 3600000), m = Math.floor((ms % 3600000) / 60000);
+    const t = h >= 48 ? `${Math.floor(h / 24)}d ${h % 24}h` : h > 0 ? `${h}h ${m}m` : `${m}m`;
+    return T("usageResets").replace("{t}", t);
+  }
+
+  function usageMetricHtml(m) {
+    if (m.type === "percent") {
+      const pct = Math.min(100, Math.max(0, m.used ?? 0));
+      const cls = pct >= 90 ? "crit" : pct >= 70 ? "warn" : "";
+      const word = pct >= 90 ? T("usageNear") : pct >= 70 ? T("usageHigh") : "";
+      const sub = usageResetText(m.resetsAt);
+      return `<div class="u-metric"><div class="u-row"><span class="u-label">${esc(m.label)}</span>` +
+        (word ? `<span class="u-status ${cls}">${esc(word)}</span>` : "") +
+        `<span class="u-val">${pct.toFixed(0)}%</span></div>` +
+        `<div class="u-meter"><div class="u-fill ${cls}" style="width:${pct}%"></div></div>` +
+        (sub ? `<div class="u-sub">${esc(sub)}</div>` : "") + `</div>`;
+    }
+    if (m.type === "dollars") {
+      const val = m.limit ? `$${(m.used ?? 0).toFixed(2)} / $${m.limit.toFixed(2)}` : `$${(m.used ?? 0).toFixed(2)}`;
+      return `<div class="u-metric"><div class="u-row"><span class="u-label">${esc(m.label)}</span><span class="u-val">${esc(val)}</span></div></div>`;
+    }
+    const val = `${m.value ?? ""} ${m.unit ?? ""}`.trim();
+    return `<div class="u-metric"><div class="u-row"><span class="u-label">${esc(m.label)}</span><span class="u-val">${esc(val)}</span></div>` +
+      (m.note ? `<div class="u-sub">${esc(m.note)}</div>` : "") + `</div>`;
+  }
+
+  function renderUsage() {
+    const box = q("usageContent");
+    if (!usageData || !Array.isArray(usageData.providers)) { box.innerHTML = `<h3>${T("usageTitle")}</h3><div class="u-err">${T("usageFail")}</div>`; return; }
+    let html = `<h3>${T("usageTitle")}</h3>`;
+    if (!usageData.providers.length) html += `<div class="u-err">${T("usageEmpty")}</div>`;
+    for (const p of usageData.providers) {
+      html += `<div class="u-provider"><div class="u-head"><span class="u-name">${esc(p.name)}</span>` +
+        (p.plan ? `<span class="u-plan">${esc(p.plan)}</span>` : "") + `</div>`;
+      if (p.status === "error") html += `<div class="u-err">${esc(p.error || "error")}</div>`;
+      else html += (p.metrics || []).map(usageMetricHtml).join("");
+      html += `</div>`;
+    }
+    const at = new Date(usageData.fetchedAt).toLocaleTimeString();
+    html += `<div class="u-foot"><span>${T("usageUpdated")} ${esc(at)}</span><button id="usageRefresh">${T("usageRefresh")}</button></div>`;
+    box.innerHTML = html;
+    const rb = q("usageRefresh");
+    if (rb) rb.onclick = () => loadUsage(true);
+  }
+
+  async function loadUsage(force) {
+    try {
+      const r = await fetch(`/api/ai-usage${force ? "?force=1" : ""}`);
+      if (r.status === 404) { q("usageBtn").style.display = "none"; return false; }
+      usageData = await r.json();
+    } catch { usageData = null; }
+    renderUsage();
+    return true;
+  }
+
+  const setUsage = (open) => {
+    q("usagePanel").classList.toggle("open", open);
+    q("helpBackdrop").classList.toggle("open", open);
+    if (open) { setHelp(false); loadUsage(false); if (!usageTimer) usageTimer = setInterval(() => loadUsage(false), 60_000); }
+    else if (usageTimer) { clearInterval(usageTimer); usageTimer = null; }
+  };
+  q("usageBtn").onclick = () => setUsage(!q("usagePanel").classList.contains("open"));
+  q("usageClose").onclick = () => setUsage(false);
+  q("helpBackdrop").addEventListener("click", () => setUsage(false));
+  q("helpBtn").addEventListener("click", () => setUsage(false));
+  window.addEventListener("keydown", (e) => { if (e.key === "Escape") setUsage(false); });
+  q("langBtn").addEventListener("click", () => { if (usageData) renderUsage(); });
+  // Probe once at boot: shows the 📊 button only when the endpoint is enabled,
+  // and warms the server-side 5-minute cache so the first open is instant.
+  loadUsage(false).then(ok => { if (ok !== false) q("usageBtn").style.display = ""; });
+
   window.addEventListener("resize", scheduleFit);
   // Catches container changes the window resize event doesn't see — chiefly the
   // profile card expanding or collapsing.

package/dist/usage/providers.d.ts

@@ -0,0 +1,26 @@
+export interface UsageMetric {
+    label: string;
+    type: "percent" | "dollars" | "count" | "text";
+    used?: number;
+    limit?: number;
+    value?: number | string;
+    unit?: string;
+    note?: string;
+    resetsAt?: string | null;
+    windowMs?: number | null;
+}
+export interface ProviderUsage {
+    id: string;
+    name: string;
+    status: "ok" | "error" | "no-credentials";
+    plan?: string | null;
+    error?: string;
+    hint?: string;
+    metrics: UsageMetric[];
+}
+/** Fetch every provider in parallel. Providers without local credentials are
+ * skipped (per the panel's contract: absent CLIs simply don't show). */
+export declare function fetchAllUsage(): Promise<{
+    fetchedAt: string;
+    providers: ProviderUsage[];
+}>;

package/dist/usage/providers.js

@@ -0,0 +1,447 @@
+/**
+ * AI subscription usage providers — read the credentials the CLI backends
+ * already saved on this machine and fetch live plan usage from each vendor's
+ * own usage endpoint. Powers `GET /api/ai-usage` (usage-api.ts) and the
+ * Usage panel on /view.
+ *
+ * Vendored from ai-usage-board (https://github.com/songsid/ai-usage-board, MIT),
+ * whose provider protocol logic is in turn ported from OpenUsage
+ * (https://github.com/robinebers/openusage, MIT, © Robin Ebers). See LICENSE.md
+ * in this directory. Not affiliated with or endorsed by OpenUsage.
+ *
+ * Token policy:
+ * - Claude/Codex: read-only, never refreshed — those vendors rotate refresh
+ *   tokens, and refreshing behind the CLI's back could invalidate its login.
+ *   Their credential files stay fresh as long as the CLIs are used (which, in
+ *   a running fleet, they are).
+ * - Grok: access tokens expire within hours, so we refresh exactly like the
+ *   Grok CLI does and persist rotated tokens back to auth.json — refusing to
+ *   refresh at all when the file isn't writable, rather than risk the login.
+ */
+import { readFile, writeFile, access, constants } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+const SESSION_MS = 5 * 60 * 60 * 1000;
+function jwtExpiryMs(token) {
+    try {
+        const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString("utf8"));
+        return typeof payload.exp === "number" ? payload.exp * 1000 : null;
+    }
+    catch {
+        return null;
+    }
+}
+// ── Claude ───────────────────────────────────────────────────────────────────
+const CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+function claudeResetIso(value) {
+    if (typeof value === "string" && value.trim()) {
+        const d = new Date(value);
+        if (!Number.isNaN(d.getTime()))
+            return d.toISOString();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        const ms = Math.abs(value) < 1e10 ? value * 1000 : value;
+        return new Date(ms).toISOString();
+    }
+    return null;
+}
+async function fetchClaudeUsage() {
+    const home = process.env.CLAUDE_HOME || join(homedir(), ".claude");
+    let oauth;
+    try {
+        oauth = JSON.parse(await readFile(join(home, ".credentials.json"), "utf8")).claudeAiOauth;
+        if (!oauth?.accessToken)
+            throw new Error("no token");
+    }
+    catch {
+        return { status: "no-credentials", hint: "Log in with the Claude Code CLI (`claude`).", metrics: [] };
+    }
+    let plan = null;
+    if (oauth.subscriptionType?.trim()) {
+        plan = oauth.subscriptionType.trim().replace(/^./, c => c.toUpperCase());
+        const tier = oauth.rateLimitTier?.match(/\d+x/);
+        if (tier)
+            plan += ` ${tier[0]}`;
+    }
+    if (oauth.expiresAt && oauth.expiresAt < Date.now()) {
+        return { status: "error", plan, error: "Access token expired. Run `claude` once to refresh it.", metrics: [] };
+    }
+    let res;
+    try {
+        res = await fetch(CLAUDE_USAGE_URL, {
+            headers: {
+                Authorization: `Bearer ${oauth.accessToken.trim()}`,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                "anthropic-beta": "oauth-2025-04-20",
+                "User-Agent": "claude-code/2.1.69",
+            },
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    catch {
+        return { status: "error", plan, error: "Could not reach api.anthropic.com.", metrics: [] };
+    }
+    if (res.status === 401 || res.status === 403) {
+        return { status: "error", plan, error: "Token rejected. Run `claude` once to refresh the login.", metrics: [] };
+    }
+    if (res.status === 429) {
+        return { status: "error", plan, error: "Rate limited by Anthropic — try again later.", metrics: [] };
+    }
+    if (!res.ok)
+        return { status: "error", plan, error: `Usage request failed (HTTP ${res.status}).`, metrics: [] };
+    let body;
+    try {
+        body = await res.json();
+    }
+    catch {
+        return { status: "error", plan, error: "Invalid response from usage endpoint.", metrics: [] };
+    }
+    const metrics = [];
+    const window = (obj, label, windowMs) => {
+        const o = obj;
+        if (typeof o?.utilization !== "number")
+            return;
+        metrics.push({ label, type: "percent", used: o.utilization, resetsAt: claudeResetIso(o.resets_at), windowMs });
+    };
+    window(body.five_hour, "Session", SESSION_MS);
+    window(body.seven_day, "Weekly", WEEK_MS);
+    window(body.seven_day_sonnet, "Sonnet (weekly)", WEEK_MS);
+    // Per-model weekly windows live in the `limits` array (kind: weekly_scoped).
+    for (const entry of Array.isArray(body.limits) ? body.limits : []) {
+        const e = entry;
+        if (e?.kind !== "weekly_scoped")
+            continue;
+        const model = e.scope?.model?.display_name;
+        if (!model || typeof e.percent !== "number")
+            continue;
+        metrics.push({ label: `${model} (weekly)`, type: "percent", used: e.percent, resetsAt: claudeResetIso(e.resets_at), windowMs: WEEK_MS });
+    }
+    const extra = body.extra_usage;
+    if (extra?.is_enabled === true && typeof extra.used_credits === "number") {
+        const used = extra.used_credits / 100;
+        const limit = typeof extra.monthly_limit === "number" && extra.monthly_limit > 0 ? extra.monthly_limit / 100 : null;
+        if (limit)
+            metrics.push({ label: "Extra usage", type: "dollars", used, limit });
+        else if (used > 0)
+            metrics.push({ label: "Extra usage", type: "dollars", used });
+    }
+    return { status: "ok", plan, metrics };
+}
+// ── Codex ────────────────────────────────────────────────────────────────────
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CREDIT_USD_RATE = 0.04;
+function codexResetIso(win, nowMs) {
+    if (typeof win.reset_at === "number" && Number.isFinite(win.reset_at))
+        return new Date(win.reset_at * 1000).toISOString();
+    if (typeof win.reset_after_seconds === "number" && Number.isFinite(win.reset_after_seconds)) {
+        return new Date(nowMs + win.reset_after_seconds * 1000).toISOString();
+    }
+    return null;
+}
+// Codex normally puts the 5-hour window in primary and weekly in secondary, but
+// a window's own limit_window_seconds wins when present. Some plans (e.g. Team)
+// report a monthly window — label by actual duration, never by slot.
+function codexWindows(rateLimit, labels, nowMs) {
+    const candidates = [
+        { win: rateLimit?.primary_window, fallback: "session" },
+        { win: rateLimit?.secondary_window, fallback: "weekly" },
+    ].filter(c => c.win && typeof c.win === "object");
+    const metrics = [];
+    for (const { win, fallback } of candidates) {
+        if (!win || typeof win.used_percent !== "number")
+            continue;
+        const explicitMs = typeof win.limit_window_seconds === "number" && Number.isFinite(win.limit_window_seconds)
+            ? win.limit_window_seconds * 1000 : null;
+        const windowMs = explicitMs ?? (fallback === "session" ? SESSION_MS : WEEK_MS);
+        let label;
+        if (windowMs === SESSION_MS)
+            label = labels.session;
+        else if (windowMs === WEEK_MS)
+            label = labels.weekly;
+        else if (windowMs >= 27 * 864e5 && windowMs <= 32 * 864e5)
+            label = labels.monthly;
+        else if (explicitMs)
+            label = labels.other(Math.round(windowMs / 864e5));
+        else
+            label = fallback === "session" ? labels.session : labels.weekly;
+        metrics.push({ label, type: "percent", used: win.used_percent, resetsAt: codexResetIso(win, nowMs), windowMs });
+    }
+    return metrics;
+}
+function codexPlan(planType) {
+    if (typeof planType !== "string" || !planType.trim())
+        return null;
+    switch (planType.trim().toLowerCase()) {
+        case "prolite": return "Pro 5x";
+        case "pro": return "Pro 20x";
+        default: return planType.trim().split("_").map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+    }
+}
+async function fetchCodexUsage() {
+    const home = process.env.CODEX_HOME || join(homedir(), ".codex");
+    let auth;
+    try {
+        auth = JSON.parse(await readFile(join(home, "auth.json"), "utf8"));
+    }
+    catch {
+        return { status: "no-credentials", hint: "Log in with the Codex CLI (`codex`).", metrics: [] };
+    }
+    const accessToken = auth?.tokens?.access_token;
+    if (!accessToken) {
+        return { status: "no-credentials", hint: "auth.json has no OAuth login (API-key-only auth cannot read usage).", metrics: [] };
+    }
+    const exp = jwtExpiryMs(accessToken);
+    if (exp && exp < Date.now()) {
+        return { status: "error", error: "Access token expired. Run `codex` once to refresh it.", metrics: [] };
+    }
+    const headers = {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json",
+        "User-Agent": "agend-usage",
+    };
+    if (auth.tokens?.account_id)
+        headers["ChatGPT-Account-Id"] = auth.tokens.account_id;
+    let res;
+    try {
+        res = await fetch(CODEX_USAGE_URL, { headers, signal: AbortSignal.timeout(10_000) });
+    }
+    catch {
+        return { status: "error", error: "Could not reach chatgpt.com.", metrics: [] };
+    }
+    if (res.status === 401 || res.status === 403) {
+        return { status: "error", error: "Token rejected. Run `codex` once to refresh the login.", metrics: [] };
+    }
+    if (!res.ok)
+        return { status: "error", error: `Usage request failed (HTTP ${res.status}).`, metrics: [] };
+    let body;
+    try {
+        body = await res.json();
+    }
+    catch {
+        return { status: "error", error: "Invalid response from usage endpoint.", metrics: [] };
+    }
+    const nowMs = Date.now();
+    const metrics = codexWindows(body.rate_limit, {
+        session: "Session", weekly: "Weekly", monthly: "Monthly", other: d => `${d}-day window`,
+    }, nowMs);
+    // Model-specific limits (e.g. Spark) ride in additional_rate_limits, same window shape.
+    for (const entry of Array.isArray(body.additional_rate_limits) ? body.additional_rate_limits : []) {
+        const e = entry;
+        if (!e || typeof e !== "object" || !e.rate_limit)
+            continue;
+        const rawName = e.limit_name || e.metered_feature || "Model limit";
+        metrics.push(...codexWindows(e.rate_limit, {
+            session: rawName, weekly: `${rawName} (weekly)`, monthly: `${rawName} (monthly)`, other: d => `${rawName} (${d}d)`,
+        }, nowMs));
+    }
+    const resets = body.rate_limit_reset_credits;
+    if (typeof resets?.available_count === "number" && resets.available_count >= 0) {
+        metrics.push({ label: "Rate limit resets", type: "count", value: Math.floor(resets.available_count), unit: "available" });
+    }
+    const credits = body.credits;
+    let remaining = null;
+    if (typeof credits?.balance === "number")
+        remaining = credits.balance;
+    else if (credits?.has_credits === false)
+        remaining = 0;
+    if (remaining !== null) {
+        const count = Math.max(0, Math.floor(remaining));
+        metrics.push({ label: "Credits", type: "count", value: count, unit: "credits", note: `≈ $${(count * CREDIT_USD_RATE).toFixed(2)}` });
+    }
+    return { status: "ok", plan: codexPlan(body.plan_type), metrics };
+}
+// ── Grok ─────────────────────────────────────────────────────────────────────
+const GROK_CREDITS_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+const GROK_SETTINGS_URL = "https://cli-chat-proxy.grok.com/v1/settings";
+const GROK_REFRESH_URL = "https://auth.x.ai/oauth2/token";
+const GROK_DEFAULT_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+const GROK_WEEKLY_PERIOD = "USAGE_PERIOD_TYPE_WEEKLY";
+const GROK_REFRESH_BUFFER_MS = 5 * 60 * 1000;
+function grokEntryExpiryMs(entry, token) {
+    const fromJwt = jwtExpiryMs(token);
+    if (fromJwt)
+        return fromJwt;
+    const raw = entry.expires_at || entry.expires;
+    if (typeof raw === "string") {
+        const ms = new Date(raw).getTime();
+        if (!Number.isNaN(ms))
+            return ms;
+    }
+    return null;
+}
+async function grokRefreshAndPersist(file, auth, entryKey, entry) {
+    // Refuse to refresh unless the rotated tokens can be written back — a rotated
+    // refresh token that only lives in our memory would break `grok` itself.
+    try {
+        await access(file, constants.W_OK);
+    }
+    catch {
+        return { error: "Token expired and auth.json is read-only. Run `grok` once to refresh it." };
+    }
+    const refreshToken = (entry.refresh_token || entry.refresh || "").trim();
+    if (!refreshToken)
+        return { error: "Token expired and no refresh token found. Run `grok login`." };
+    const clientId = entry.oidc_client_id?.trim()
+        || entryKey.split("::").pop()?.trim()
+        || GROK_DEFAULT_CLIENT_ID;
+    let res;
+    try {
+        res = await fetch(GROK_REFRESH_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({ grant_type: "refresh_token", client_id: clientId, refresh_token: refreshToken }),
+            signal: AbortSignal.timeout(15_000),
+        });
+    }
+    catch {
+        return { error: "Could not reach auth.x.ai to refresh the token." };
+    }
+    if (!res.ok)
+        return { error: "Grok session expired. Run `grok login` again." };
+    let body;
+    try {
+        body = await res.json();
+    }
+    catch {
+        return { error: "Invalid refresh response from auth.x.ai." };
+    }
+    if (!body.access_token)
+        return { error: "Grok session expired. Run `grok login` again." };
+    // Update only this entry's fields, preserving everything else in the file
+    // (other accounts' entries included).
+    const updated = { ...(auth[entryKey] ?? {}) };
+    updated.key = body.access_token;
+    if (body.refresh_token)
+        updated.refresh_token = body.refresh_token;
+    if (body.id_token)
+        updated.id_token = body.id_token;
+    if (typeof body.expires_in === "number")
+        updated.expires_at = new Date(Date.now() + body.expires_in * 1000).toISOString();
+    try {
+        await writeFile(file, JSON.stringify({ ...auth, [entryKey]: updated }, null, 2));
+    }
+    catch {
+        return { error: "Refreshed but could not write auth.json — refusing to continue without persisting. Run `grok` once instead." };
+    }
+    return { token: body.access_token };
+}
+function grokHeaders(token) {
+    return {
+        Authorization: `Bearer ${token.trim()}`,
+        "X-XAI-Token-Auth": "xai-grok-cli",
+        Accept: "application/json",
+        "User-Agent": "agend-usage",
+    };
+}
+async function fetchGrokUsage() {
+    const home = process.env.GROK_HOME || join(homedir(), ".grok");
+    const file = join(home, "auth.json");
+    let auth;
+    try {
+        auth = JSON.parse(await readFile(file, "utf8"));
+    }
+    catch {
+        return { status: "no-credentials", hint: "Log in with the Grok CLI (`grok login`).", metrics: [] };
+    }
+    const entries = Object.entries(auth).filter(([, e]) => typeof e?.key === "string" && e.key.trim());
+    if (!entries.length)
+        return { status: "no-credentials", hint: "auth.json has no usable login. Run `grok login`.", metrics: [] };
+    const [entryKey, entry] = entries[0];
+    let token = entry.key.trim();
+    const expiry = grokEntryExpiryMs(entry, token);
+    if (expiry && expiry - Date.now() <= GROK_REFRESH_BUFFER_MS) {
+        const refreshed = await grokRefreshAndPersist(file, auth, entryKey, entry);
+        if (refreshed.error)
+            return { status: "error", error: refreshed.error, metrics: [] };
+        token = refreshed.token;
+    }
+    const fetchBoth = async (tok) => {
+        const [credits, settings] = await Promise.all([
+            fetch(GROK_CREDITS_URL, { headers: grokHeaders(tok), signal: AbortSignal.timeout(10_000) }),
+            fetch(GROK_SETTINGS_URL, { headers: grokHeaders(tok), signal: AbortSignal.timeout(10_000) }).catch(() => null),
+        ]);
+        return { credits, settings };
+    };
+    let credits, settings;
+    try {
+        ({ credits, settings } = await fetchBoth(token));
+        if (credits.status === 401 || credits.status === 403) {
+            const refreshed = await grokRefreshAndPersist(file, auth, entryKey, entry);
+            if (refreshed.error)
+                return { status: "error", error: refreshed.error, metrics: [] };
+            token = refreshed.token;
+            ({ credits, settings } = await fetchBoth(token));
+        }
+    }
+    catch {
+        return { status: "error", error: "Could not reach cli-chat-proxy.grok.com.", metrics: [] };
+    }
+    if (credits.status === 401 || credits.status === 403) {
+        return { status: "error", error: "Grok session expired. Run `grok login` again.", metrics: [] };
+    }
+    if (!credits.ok)
+        return { status: "error", error: `Billing request failed (HTTP ${credits.status}).`, metrics: [] };
+    let body;
+    try {
+        body = await credits.json();
+    }
+    catch {
+        return { status: "error", error: "Invalid response from billing endpoint.", metrics: [] };
+    }
+    const config = body?.config;
+    const period = config?.currentPeriod;
+    if (!config || !period?.type)
+        return { status: "error", error: "Grok billing response changed.", metrics: [] };
+    const metrics = [];
+    if (period.type === GROK_WEEKLY_PERIOD) {
+        // proto-JSON drops zero-valued fields: an absent creditUsagePercent means 0%.
+        const pct = typeof config.creditUsagePercent === "number" ? config.creditUsagePercent : 0;
+        const start = new Date(period.start ?? "").getTime();
+        const end = new Date(period.end ?? "").getTime();
+        metrics.push({
+            label: "Weekly limit",
+            type: "percent",
+            used: Math.min(100, Math.max(0, pct)),
+            resetsAt: Number.isNaN(end) ? null : new Date(end).toISOString(),
+            windowMs: Number.isNaN(end - start) ? null : end - start,
+        });
+    }
+    const cap = typeof config.onDemandCap?.val === "number" ? config.onDemandCap.val : 0;
+    metrics.push({ label: "Pay as you go", type: "text", value: cap > 0 ? `${cap} cap` : "Disabled" });
+    let plan = null;
+    if (settings?.ok) {
+        try {
+            const s = await settings.json();
+            if (typeof s.subscription_tier_display === "string" && s.subscription_tier_display.trim()) {
+                plan = s.subscription_tier_display.trim();
+            }
+        }
+        catch { /* plan is optional */ }
+    }
+    return { status: "ok", plan, metrics };
+}
+// ── Registry ─────────────────────────────────────────────────────────────────
+const PROVIDERS = [
+    { id: "claude", name: "Claude", fetch: fetchClaudeUsage },
+    { id: "codex", name: "Codex", fetch: fetchCodexUsage },
+    { id: "grok", name: "Grok", fetch: fetchGrokUsage },
+];
+/** Fetch every provider in parallel. Providers without local credentials are
+ * skipped (per the panel's contract: absent CLIs simply don't show). */
+export async function fetchAllUsage() {
+    const results = await Promise.all(PROVIDERS.map(async (p) => {
+        try {
+            return { id: p.id, name: p.name, ...(await p.fetch()) };
+        }
+        catch (err) {
+            return { id: p.id, name: p.name, status: "error", error: String(err?.message ?? err), metrics: [] };
+        }
+    }));
+    return {
+        fetchedAt: new Date().toISOString(),
+        providers: results.filter(r => r.status !== "no-credentials"),
+    };
+}
+//# sourceMappingURL=providers.js.map