npm - agents-deck - Versions diffs - 1.20.0 → 1.20.2 - Mend

agents-deck 1.20.0 → 1.20.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/web/assets/{index-xwyRF1NY.js → index-Cb1bIpZv.js} +1 -1
package/dist/web/index.html +1 -1
package/package.json +1 -1
package/src/server/quota.mjs +197 -25

package/dist/web/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>agents-deck</title>
     <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Ctext y='84' font-size='84'%3E%E2%97%89%3C/text%3E%3C/svg%3E" />
-    <script type="module" crossorigin src="/assets/index-xwyRF1NY.js"></script>
+    <script type="module" crossorigin src="/assets/index-Cb1bIpZv.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-_qWQOt8_.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "agents-deck",
-  "version": "1.20.0",
+  "version": "1.20.2",
   "description": "Live deck of Claude Code and Codex agents — watch parallel subagents fork, call tools, and return on one calm canvas.",
   "type": "module",
   "bin": {

package/src/server/quota.mjs CHANGED Viewed

@@ -1,20 +1,145 @@
-// Fetches Claude rate-limit quota by running `claude --print /usage`.
-// On Windows the binary is a .cmd wrapper — we use exec() (shell-based)
-// so that cmd.exe handles quoting and stdin redirect correctly.
-// Caches the result for 2 minutes.
+// Fetches Claude rate-limit quota.
+//
+// Primary source: Anthropic's OAuth usage API
+//   GET https://api.anthropic.com/api/oauth/usage
+//   Auth: Bearer token from ~/.claude/.credentials.json (claudeAiOauth.accessToken)
+// This is instant and exact — same data the `/usage` command shows, but with no
+// cold-start gap (the CLI omits the quota lines on its first invocation after
+// idle). Mechanism reverse-engineered from steipete/CodexBar.
+//
+// Fallback: parse `claude --print /usage` CLI output (used only if the API call
+// fails — no token, expired token, network error). On Windows the binary is a
+// .cmd wrapper, so we use exec() (shell-based) for correct quoting + stdin.
+//
+// Result is cached for 60s.
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir, platform } from "node:os";
 const execAsync = promisify(exec);
 const IS_WIN = platform() === "win32";
-let _cache = null;
-let _cacheAt = 0;
+const CREDS_PATH  = join(homedir(), ".claude", ".credentials.json");
+const USAGE_URL   = "https://api.anthropic.com/api/oauth/usage";
+const BETA_HEADER = "oauth-2025-04-20";
+const WIN_5H_SEC  = 18000;
+const WIN_7D_SEC  = 604800;
+// 429 cooldown gate — after a rate-limit, skip the API until this passes.
+let _rateLimitedUntil = 0;
+async function readOAuthToken() {
+  try {
+    const raw  = await readFile(CREDS_PATH, "utf8");
+    const auth = JSON.parse(raw)?.claudeAiOauth;
+    if (!auth?.accessToken) return null;
+    // expiresAt is epoch milliseconds. If expired, the CLI fallback handles it.
+    if (auth.expiresAt && Date.now() >= auth.expiresAt) return null;
+    return auth.accessToken;
+  } catch {
+    return null;
+  }
+}
+// ISO-8601 → "Jun 19, 1:19pm" (local time, matching the CLI display format).
+function fmtResetIso(iso) {
+  if (!iso) return null;
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) return null;
+  // "Jun 19, 1:19 PM" → "Jun 19, 1:19pm" (matches the CLI display format)
+  return d.toLocaleString("en-US", {
+    month: "short", day: "numeric", hour: "numeric", minute: "2-digit", hour12: true,
+  }).replace(/\s+(AM|PM)/, (_, p) => p.toLowerCase());
+}
+function isoToSec(iso) {
+  if (!iso) return null;
+  const t = new Date(iso).getTime();
+  return isNaN(t) ? null : Math.floor(t / 1000);
+}
+// Map the OAuth usage JSON to our quota result shape.
+// utilization is already a 0–100 percentage. 5h falls back to 7d if absent.
+function mapOAuthUsage(data) {
+  const fh = data?.five_hour;
+  const sd = data?.seven_day;
+  const son = data?.seven_day_sonnet;
+  const opus = data?.seven_day_opus;
+  const primary = (fh?.utilization != null) ? fh : sd;
+  if (!primary || primary.utilization == null) return null;
+  const round = (v) => Math.min(100, Math.max(0, Math.round(v)));
+  const result = {
+    session5hPct:       round(primary.utilization),
+    session5hWindowSec: WIN_5H_SEC,
+    session5hReset:     fmtResetIso(primary.resets_at),
+    session5hResetAt:   isoToSec(primary.resets_at),
+    week7dWindowSec:    WIN_7D_SEC,
+  };
+  if (sd?.utilization != null) {
+    result.week7dPct     = round(sd.utilization);
+    result.week7dReset   = fmtResetIso(sd.resets_at);
+    result.week7dResetAt = isoToSec(sd.resets_at);
+  } else {
+    result.week7dPct = 0;
+  }
+  if (son?.utilization != null)  result.weekSonnetPct = round(son.utilization);
+  if (opus?.utilization != null) result.weekOpusPct   = round(opus.utilization);
+  // extra usage credits (pay-as-you-go top-up), if enabled
+  const extra = data?.extra_usage;
+  if (extra?.is_enabled) {
+    result.extraEnabled = true;
+    if (extra.used_credits != null)  result.extraUsedCredits  = extra.used_credits;
+    if (extra.monthly_limit != null) result.extraMonthlyLimit = extra.monthly_limit;
+    if (extra.currency)              result.extraCurrency     = extra.currency;
+  }
+  return result;
+}
+async function fetchOAuthUsage() {
+  if (Date.now() < _rateLimitedUntil) return null;
+  const token = await readOAuthToken();
+  if (!token) return null;
+  try {
+    const res = await fetch(USAGE_URL, {
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "anthropic-beta": BETA_HEADER,
+        "Accept":         "application/json",
+        "Content-Type":   "application/json",
+        "User-Agent":     "claude-code/2.1.0",
+      },
+      signal: AbortSignal.timeout(15_000),
+    });
+    if (res.status === 429) {
+      const retryAfter = parseInt(res.headers.get("retry-after") ?? "", 10);
+      const cooldownMs = Number.isFinite(retryAfter) ? retryAfter * 1000 : 5 * 60_000;
+      _rateLimitedUntil = Date.now() + cooldownMs;
+      return null;
+    }
+    if (!res.ok) return null;
+    return mapOAuthUsage(await res.json());
+  } catch {
+    return null;
+  }
+}
+let _cache    = null;
+let _cacheAt  = 0;
+let _inflight = null;   // deduplicates concurrent exec() calls
+let _lastGood = null;   // last result that had real quota percentages
 const CACHE_MS = 60_000;
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
 function stripAnsi(s) {
   return s
     .replace(/\x1B\[[0-9;]*[A-Za-z]/g, "")
@@ -122,10 +247,20 @@ export async function fetchClaudeQuota({ force = false } = {}) {
   const now = Date.now();
   if (!force && _cache && now - _cacheAt < CACHE_MS) return _cache;
-  const shellCmd = buildQuotaShellCmd();
-  let parsed = null;
+  // If another exec() is already in flight, wait for it instead of spawning a
+  // second concurrent process (which can return empty output and overwrite the
+  // good result with 0%).
+  if (_inflight) return _inflight;
-  let cliOk = false;
+  _inflight = _doFetch(now).finally(() => { _inflight = null; });
+  return _inflight;
+}
+// Run `claude --print /usage` once. Returns { cliOk, parsed }.
+//   cliOk  — the CLI ran and we recognized its output (preamble present)
+//   parsed — quota percentages object, or null if the "Current session/week"
+//            lines were absent (CLI cold-start, or genuinely <1% usage)
+async function _execOnce(shellCmd) {
   try {
     const { stdout, stderr } = await execAsync(shellCmd, {
       timeout: 15_000,
@@ -133,34 +268,71 @@ export async function fetchClaudeQuota({ force = false } = {}) {
       maxBuffer: 1024 * 1024,
     });
     const combined = stdout + "\n" + stderr;
-    // CLI ran successfully if we see the subscription preamble.
-    cliOk = /subscription/i.test(combined) || /claude code usage/i.test(combined);
-    parsed = parseUsageText(combined);
+    const cliOk = /subscription/i.test(combined) || /claude code usage/i.test(combined);
+    return { cliOk, parsed: parseUsageText(combined) };
   } catch (err) {
     const msg = err?.stderr ? stripAnsi(err.stderr).trim() : (err?.message ?? String(err));
     console.error("agents-deck quota: claude CLI failed:", msg);
     if (err?.stdout || err?.stderr) {
       const combined = (err.stdout ?? "") + "\n" + (err.stderr ?? "");
-      cliOk = /subscription/i.test(combined);
-      parsed = parseUsageText(combined);
+      return { cliOk: /subscription/i.test(combined), parsed: parseUsageText(combined) };
     }
+    return { cliOk: false, parsed: null };
   }
+}
-  // CLI ran OK but quota lines were absent — this happens when the rolling
-  // window has near-zero usage (Claude omits bars below ~1%). Treat as 0%.
-  if (cliOk && !parsed) {
-    parsed = {
-      session5hPct: 0, session5hWindowSec: 18000,
-      week7dPct:    0, week7dWindowSec:    604800,
-    };
+async function _doFetch(now) {
+  // Primary: OAuth usage API — instant, exact, no cold-start gap.
+  const api = await fetchOAuthUsage();
+  if (api) {
+    const result = { ok: true, ...api, source: "api", fetchedAt: now };
+    _cache = result; _cacheAt = now;
+    _lastGood = result;
+    return result;
   }
-  const result = parsed
-    ? { ok: true, ...parsed, fetchedAt: now }
-    : { ok: false, fetchedAt: now };
+  // Fallback: parse `claude --print /usage` CLI output.
+  const shellCmd = buildQuotaShellCmd();
+  // The CLI sometimes omits the "Current session/week" quota lines on a cold
+  // invocation (right after the server starts, or after the page is hard-
+  // refreshed). The real lines appear on a subsequent call. Retry a couple
+  // times before giving up so the first paint already shows real values.
+  let cliOk = false;
+  let parsed = null;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    if (attempt > 0) await sleep(1200);
+    const r = await _execOnce(shellCmd);
+    cliOk = r.cliOk || cliOk;
+    if (r.parsed) { parsed = r.parsed; break; }
+  }
+  // Got real quota lines — cache normally and remember as last-known-good.
+  if (parsed) {
+    const result = { ok: true, ...parsed, fetchedAt: now };
+    _cache = result; _cacheAt = now;
+    _lastGood = result;
+    return result;
+  }
+  // No quota lines after retries. If we've ever seen real values, keep showing
+  // them rather than regressing to 0% on a transient empty read. Short-cache so
+  // we retry the CLI again soon.
+  if (_lastGood) {
+    const result = { ..._lastGood, fetchedAt: now, stale: true };
+    _cache = result;
+    _cacheAt = now - (CACHE_MS - 5_000);
+    return result;
+  }
+  // Never had good data. CLI ran but lines absent → treat as genuine <1%.
+  // CLI failed entirely → ok:false. Either way short-cache for a quick retry.
+  const result = cliOk
+    ? { ok: true, session5hPct: 0, session5hWindowSec: 18000,
+        week7dPct: 0, week7dWindowSec: 604800, fetchedAt: now }
+    : { ok: false, fetchedAt: now };
   _cache = result;
-  _cacheAt = now;
+  _cacheAt = now - (CACHE_MS - 5_000);
   return result;
 }