ai-usage-analyzer 0.4.0 → 0.5.0

package/src/markdown.js

@@ -31,9 +31,10 @@ export function fmtCompact(n) {
   return String(n || 0);
 }
 
-function fmtCost(n) {
+function fmtCost(n, status) {
+  if (status === "unavailable") return "unavailable";
   if (!n) return "—";
-  return "$" + Number(n).toFixed(2);
+  return (status === "estimated" || status === "partial" ? "~" : "") + "$" + Number(n).toFixed(2) + (status === "partial" ? " (partial)" : "");
 }
 
 function compactHome(p) {
@@ -131,9 +132,8 @@ export function renderMarkdown({
     out.push(`**Range**: ${dateRange[0] ?? "—"} → ${dateRange[1] ?? "—"}  `);
     out.push(`**Sessions**: ${fmtInt(records.length)}  `);
     out.push(`**Total tokens**: ${fmtCompact(tot.tokensTotal)}  `);
-    if (tot.cost > 0) {
-      out.push(`**Cost**: ${fmtCost(tot.cost)} (opencode only)  `);
-    }
+    out.push(`**Cost**: ${fmtCost(tot.cost, tot.costStatus)}  `);
+    if (tot.unknownModels.length) out.push(`**Unpriced models**: ${tot.unknownModels.map(mdEscape).join(", ")}  `);
   } else {
     out.push(`**No session data available** — only detection status below.`);
   }
@@ -174,11 +174,11 @@ export function renderMarkdown({
   out.push(`|---|---:|---:|---:|---:|`);
   for (const t of tools) {
     out.push(
-      `| ${mdEscape(t.tool)} | ${fmtInt(t.n)} | ${fmtCompact(t.tokensTotal)} | ${fmtCompact(t.avg)} | ${fmtCost(t.cost)} |`,
+      `| ${mdEscape(t.tool)} | ${fmtInt(t.n)} | ${fmtCompact(t.tokensTotal)} | ${fmtCompact(t.avg)} | ${fmtCost(t.cost, t.costStatus)} |`,
     );
   }
   out.push(
-    `| **TOTAL** | **${fmtInt(records.length)}** | **${fmtCompact(tot.tokensTotal)}** | **${fmtCompact(tot.avg)}** | **${fmtCost(tot.cost)}** |`,
+    `| **TOTAL** | **${fmtInt(records.length)}** | **${fmtCompact(tot.tokensTotal)}** | **${fmtCompact(tot.avg)}** | **${fmtCost(tot.cost, tot.costStatus)}** |`,
   );
   out.push(``);
 
@@ -245,7 +245,7 @@ export function renderMarkdown({
     for (const p of toolRows) {
       const cache = p.tokensCacheRead + p.tokensCacheWrite;
       out.push(
-        `| ${mdEscape(p.tool)} | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${fmtCost(p.cost)} | ${fmtCompact(p.avg)} | ${bar(p.tokensTotal, max, 20)} |`,
+        `| ${mdEscape(p.tool)} | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${fmtCost(p.cost, p.costStatus)} | ${fmtCompact(p.avg)} | ${bar(p.tokensTotal, max, 20)} |`,
       );
     }
     out.push(``);
@@ -316,7 +316,7 @@ export function renderMarkdown({
     top.forEach((r, i) => {
       const proj = compactHome(r.project);
       out.push(
-        `| ${i + 1} | ${fmtCompact(r.tokensTotal)} | ${fmtCompact(r.tokensInput)} | ${fmtCompact(r.tokensOutput)} | ${r.cost ? "$" + r.cost.toFixed(4) : "—"} | ${mdEscape(shortModel(r.model))} | \`${mdEscape(proj)}\` | ${mdEscape(r.title || "—")} |`,
+        `| ${i + 1} | ${fmtCompact(r.tokensTotal)} | ${fmtCompact(r.tokensInput)} | ${fmtCompact(r.tokensOutput)} | ${fmtCost(r.cost, r.costStatus)} | ${mdEscape(shortModel(r.model))} | \`${mdEscape(proj)}\` | ${mdEscape(r.title || "—")} |`,
       );
     });
     out.push(``);
@@ -325,6 +325,8 @@ export function renderMarkdown({
   // Notes ---------------------------------------------------------------
   out.push(`## Notes`);
   out.push(``);
+  out.push(`Costs marked ~ are API-equivalent estimates; partial totals exclude unpriced usage. Recorded costs come from local tool data and are not necessarily subscription charges.`);
+  out.push(``);
   out.push(`### Token Definitions`);
   out.push(``);
   out.push(`- **Input** — prompt tokens sent to the model`);
@@ -333,7 +335,7 @@ export function renderMarkdown({
     `- **Cache Read** — prompt tokens served from the provider's cache (cheap)`,
   );
   out.push(
-    `- **Cache Write** — prompt tokens cached for future use (OpenCode only)`,
+    `- **Cache Write** — prompt tokens cached for future use`,
   );
   out.push(`- **Reasoning** — extended thinking / chain-of-thought tokens`);
   out.push(``);

package/src/pricing.js

@@ -0,0 +1,49 @@
+export const PRICING_VERSION = '2026-10-27';
+
+const PRICES = {
+  claude: [
+    [/^claude-opus-4-[5678](?:-\d{8})?$/, [5, 25, 0.5, 6.25]],
+    [/^claude-sonnet-4-6(?:-\d{8})?$/, [3, 15, 0.3, 3.75]],
+    [/^claude-sonnet-4-5(?:-\d{8})?$/, [3, 15, 0.3, 3.75], 200000],
+    [/^claude-sonnet-4(?:-\d{8})?$/, [3, 15, 0.3, 3.75], 200000],
+    [/^claude-haiku-4-5(?:-\d{8})?$/, [1, 5, 0.1, 1.25]],
+    [/^claude-3-5-haiku(?:-\d{8})?$/, [0.8, 4, 0.08, 1]],
+  ],
+  codex: [
+    [/^gpt-5-5(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [5, 30, 0.5, 0], 272000],
+    [/^gpt-5-4-mini(?:-\d{4}-\d{2}-\d{2})?$/, [0.75, 4.5, 0.075, 0]],
+    [/^gpt-5-4-nano(?:-\d{4}-\d{2}-\d{2})?$/, [0.2, 1.25, 0.02, 0]],
+    [/^gpt-5-4-pro(?:-\d{4}-\d{2}-\d{2})?$/, [30, 180, 0, 0], 272000],
+    [/^gpt-5-4(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [2.5, 15, 0.25, 0], 272000],
+    [/^gpt-5-[23](?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [1.75, 14, 0.175, 0]],
+    [/^gpt-5-1(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [1.25, 10, 0.125, 0]],
+    [/^gpt-5-1-codex-mini(?:-\d{4}-\d{2}-\d{2})?$/, [0.25, 2, 0.025, 0]],
+    [/^gpt-5-mini(?:-\d{4}-\d{2}-\d{2})?$/, [0.25, 2, 0.025, 0]],
+    [/^gpt-5-nano(?:-\d{4}-\d{2}-\d{2})?$/, [0.05, 0.4, 0.005, 0]],
+    [/^gpt-5(?:(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?)$/, [1.25, 10, 0.125, 0]],
+  ],
+};
+
+export function estimateUsage(tool, events) {
+  let cost = 0;
+  let priced = 0;
+  const unknown = new Set();
+  for (const { model, usage, provider, aggregated, ambiguousModel } of events) {
+    const name = String(model || '').toLowerCase().replace(/[._ ]/g, '-').split('/').pop();
+    const price = (PRICES[tool] || []).find(([pattern]) => pattern.test(name));
+    if (!price || (tool === 'codex' && provider && provider.toLowerCase() !== 'openai')) { unknown.add(model || '(unknown model)'); continue; }
+    if (aggregated || ambiguousModel) { unknown.add(`${model || '(unknown model)'} (aggregate usage)`); continue; }
+    const [inputRate, outputRate, cacheRate, writeRate] = price[1];
+    const nonnegative = value => Number.isFinite(Number(value)) ? Math.max(0, Number(value)) : 0;
+    const rawInput = nonnegative(usage.input_tokens);
+    const cache = nonnegative(tool === 'codex' ? usage.cached_input_tokens : usage.cache_read_input_tokens);
+    const input = tool === 'codex' ? Math.max(0, rawInput - cache) : rawInput;
+    const output = nonnegative(usage.output_tokens);
+    const write = nonnegative(usage.cache_creation_input_tokens);
+    const prompt = rawInput + (tool === "claude" ? cache + write : 0);
+    const long = price[2] && prompt > price[2];
+    cost += (input * inputRate * (long ? 2 : 1) + output * outputRate * (long ? 1.5 : 1) + cache * cacheRate * (long ? 2 : 1) + write * writeRate * (long ? 2 : 1)) / 1000000;
+    priced++;
+  }
+  return { cost, costStatus: unknown.size ? (priced ? 'partial' : 'unavailable') : 'estimated', unknownModels: [...unknown] };
+}

package/src/quota.js

@@ -0,0 +1,194 @@
+import { readFile, open, rename, unlink, stat } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+function number(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function resetTime(value) {
+  const seconds = number(value);
+  if (seconds === null || seconds <= 0) return null;
+  const date = new Date(seconds * 1000);
+  return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+
+export function parseCodexQuota(data) {
+  const windows = [];
+  function add(rate, prefix = '') {
+    for (const w of [rate?.primary_window, rate?.secondary_window]) {
+      if (!w || number(w.used_percent) === null) continue;
+      const duration = number(w.limit_window_seconds);
+      const name = duration === 18000 ? 'Session' : duration === 604800 ? 'Weekly' : 'Limit';
+      windows.push({ label: prefix ? `${prefix} ${name}` : name, usedPercent: number(w.used_percent), resetAt: resetTime(w.reset_at) });
+    }
+  }
+  add(data.rate_limit);
+  for (const extra of data.additional_rate_limits || []) {
+    const name = extra.limit_name || extra.metered_feature || 'Additional';
+    add(extra.rate_limit, /spark/i.test(name) ? 'Codex Spark' : name);
+  }
+  const spend = data.spend_control?.individual_limit;
+  if (spend) {
+    const used = number(spend.used), limit = number(spend.limit);
+    const percent = number(spend.used_percent) ?? (limit > 0 && used !== null ? used / limit * 100 : null);
+    if (percent !== null) windows.push({ label: 'Monthly spend', usedPercent: percent, resetAt: resetTime(spend.reset_at) });
+  }
+  return { windows, plan: data.plan_type || null };
+}
+
+export function parseClaudeQuota(data) {
+  const windows = [];
+  for (const [field, label] of [['five_hour', 'Session'], ['seven_day', 'Weekly'], ['seven_day_oauth_apps', 'OAuth Apps'], ['seven_day_sonnet', 'Sonnet'], ['seven_day_opus', 'Opus']]) {
+    const w = data[field];
+    if (w && number(w.utilization) !== null) windows.push({ label, usedPercent: number(w.utilization), resetAt: w.resets_at || null });
+  }
+  for (const [fields, label] of [
+    [['seven_day_design', 'seven_day_claude_design', 'claude_design', 'design', 'seven_day_omelette', 'omelette', 'omelette_promotional'], 'Designs'],
+    [['seven_day_routines', 'seven_day_claude_routines', 'claude_routines', 'routines', 'routine', 'seven_day_cowork', 'cowork'], 'Daily Routines'],
+  ]) {
+    const w = fields.map(field => data[field]).find(Boolean);
+    if (w && number(w.utilization) !== null) windows.push({ label, usedPercent: number(w.utilization), resetAt: w.resets_at || null });
+  }
+  const extra = data.extra_usage;
+  const limit = number(extra?.monthly_limit), used = number(extra?.used_credits);
+  const percent = number(extra?.utilization) ?? (limit > 0 && used !== null ? used / limit * 100 : null);
+  if (extra?.is_enabled && percent !== null) windows.push({ label: 'Extra usage', usedPercent: percent, resetAt: null, used: used === null ? null : used / 100, limit: limit === null ? null : limit / 100, currency: extra.currency || 'USD' });
+  return { windows };
+}
+
+export async function fetchQuota(provider, credentials, fetcher = fetch, signal, versionReader) {
+  if (provider !== 'claude' && provider !== 'codex') throw new Error('Unsupported quota provider');
+  if (!credentials?.accessToken) throw new Error('No OAuth access token available');
+  const claude = provider === 'claude';
+  const headers = { Authorization: `Bearer ${credentials.accessToken}`, Accept: 'application/json' };
+  if (claude) {
+    headers['anthropic-beta'] = 'oauth-2025-04-20';
+    let version = '2.1.0';
+    try {
+      const reader = versionReader || (async () => (await execFileAsync('claude', ['--version'], { timeout: 1000, maxBuffer: 4096, signal })).stdout);
+      const output = await reader();
+      version = String(output).match(/\b\d+\.\d+\.\d+\b/)?.[0] || version;
+    } catch {}
+    signal?.throwIfAborted();
+    headers['User-Agent'] = `claude-code/${version}`;
+  } else if (credentials.accountId) {
+    headers['ChatGPT-Account-Id'] = credentials.accountId;
+  }
+  const response = await fetcher(claude ? 'https://api.anthropic.com/api/oauth/usage' : 'https://chatgpt.com/backend-api/wham/usage', { headers, signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(30000)]) : AbortSignal.timeout(30000) });
+  if (response.status === 401 || response.status === 403) {
+    throw new Error(claude ? 'Claude login is invalid or lacks access; run claude to log in again' : 'Codex login is invalid; run codex login');
+  }
+  if (!response.ok) throw new Error(`Quota request failed (HTTP ${response.status})`);
+  const data = await response.json();
+  const result = { provider, ...(claude ? parseClaudeQuota(data) : parseCodexQuota(data)) };
+  if (!claude && credentials.idToken && credentials.idToken.length < 65536) {
+    try {
+      const claims = JSON.parse(Buffer.from(credentials.idToken.split('.')[1], 'base64url').toString('utf8'));
+      if (typeof claims.email === 'string') result.email = claims.email;
+      if (!result.plan && typeof claims['https://api.openai.com/auth']?.chatgpt_plan_type === 'string') result.plan = claims['https://api.openai.com/auth'].chatgpt_plan_type;
+    } catch {}
+  }
+  return result;
+}
+
+export async function readCredentials(provider, env = process.env, options = {}) {
+  if (provider === 'codex') {
+    const file = join(env.CODEX_HOME || join(homedir(), '.codex'), 'auth.json');
+    const auth = JSON.parse(await readFile(file, 'utf8'));
+    if (auth.OPENAI_API_KEY) throw new Error('OAuth usage limits require codex login');
+    return { accessToken: auth.tokens?.access_token, refreshToken: auth.tokens?.refresh_token, idToken: auth.tokens?.id_token, accountId: auth.tokens?.account_id, lastRefresh: auth.last_refresh, authPath: file };
+  }
+  if (provider !== 'claude') throw new Error('Unsupported quota provider');
+  const token = env.TOKCAT_CLAUDE_OAUTH_TOKEN || env.CODEXBAR_CLAUDE_OAUTH_TOKEN;
+  if (token) return { accessToken: token };
+  let raw;
+  if ((options.platform || process.platform) === 'darwin') {
+    const getKeychain = options.getKeychain || (async () => (await execFileAsync('/usr/bin/security', ['find-generic-password', '-s', 'Claude Code-credentials', '-w'], { timeout: 5000, maxBuffer: 1024 * 1024, signal: options.signal })).stdout);
+    try { raw = await getKeychain(); }
+    catch (error) {
+      if (options.signal?.aborted) throw error;
+      if (error.killed || error.code === 'ETIMEDOUT') throw new Error('Claude Keychain access timed out; check the permission prompt');
+    }
+  }
+  if (!raw) {
+    const file = join(env.CLAUDE_HOME || join(homedir(), '.claude'), '.credentials.json');
+    raw = await readFile(file, 'utf8');
+  }
+  const oauth = JSON.parse(raw).claudeAiOauth || {};
+  if (oauth.expiresAt && oauth.expiresAt <= Date.now()) throw new Error('Claude token expired; run claude to refresh it');
+  if (oauth.scopes && !oauth.scopes.includes('user:profile')) throw new Error('Claude login lacks user:profile scope');
+  return { accessToken: oauth.accessToken };
+}
+
+export async function refreshCodexCredentials(path, fetcher = fetch, signal) {
+  const original = await readFile(path, 'utf8');
+  const auth = JSON.parse(original);
+  if (!auth.tokens?.refresh_token) throw new Error('Codex refresh token unavailable; run codex login');
+  const response = await fetcher('https://auth.openai.com/oauth/token', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+    body: JSON.stringify({ client_id: 'app_EMoamEEZ73f0CkXaXp7hrann', grant_type: 'refresh_token', refresh_token: auth.tokens.refresh_token, scope: 'openid profile email' }),
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(30000)]) : AbortSignal.timeout(30000),
+  });
+  if (!response.ok) throw new Error('Codex refresh failed; run codex login');
+  const tokens = await response.json();
+  if (!tokens.access_token) throw new Error('Codex refresh returned incomplete credentials; run codex login');
+  auth.tokens = { ...auth.tokens, access_token: tokens.access_token, refresh_token: tokens.refresh_token || auth.tokens.refresh_token, ...(tokens.id_token ? { id_token: tokens.id_token } : {}) };
+  auth.last_refresh = new Date().toISOString();
+  const temp = `${path}.${randomUUID()}.tmp`;
+  let handle;
+  try {
+    const mode = (await stat(path)).mode & 0o600;
+    handle = await open(temp, 'wx', mode || 0o600);
+    await handle.writeFile(JSON.stringify(auth, null, 2));
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    if (await readFile(path, 'utf8') !== original) throw new Error('Codex credentials changed during refresh; run codex login if needed');
+    await rename(temp, path);
+  } finally {
+    if (handle) await handle.close();
+    await unlink(temp).catch(() => {});
+  }
+  return { accessToken: auth.tokens.access_token, refreshToken: auth.tokens.refresh_token, idToken: auth.tokens.id_token, accountId: auth.tokens.account_id, lastRefresh: auth.last_refresh, authPath: path };
+}
+
+export async function collectQuotas(options = {}) {
+  const read = options.read || ((provider) => readCredentials(provider, process.env, { signal: options.signal }));
+  const refresh = options.refresh || ((path) => refreshCodexCredentials(path, fetch));
+  const request = options.fetch || ((provider, credentials) => fetchQuota(provider, credentials, fetch, options.signal));
+  return Promise.all(['claude', 'codex'].map(async (provider) => {
+    try {
+      let credentials = await read(provider);
+      options.signal?.throwIfAborted();
+      const refreshedAt = Date.parse(credentials.lastRefresh);
+      if (provider === 'codex' && (!Number.isFinite(refreshedAt) || Date.now() - refreshedAt > 8 * 86400000)) {
+        credentials = await refresh(credentials.authPath);
+      }
+      options.signal?.throwIfAborted();
+      return await request(provider, credentials);
+    } catch (error) {
+      const safe = /^(Claude token expired|Claude login lacks|Claude login is invalid|Codex login is invalid|Claude Keychain access|OAuth usage limits|Codex refresh|Codex credentials changed|No OAuth access token|Quota request failed)/;
+      const message = safe.test(error.message || '') ? error.message : 'Quota unavailable; check your login and network connection';
+      return { provider, windows: [], error: message };
+    }
+  }));
+}
+
+export function renderQuota(quotas) {
+  if (!quotas) return 'Loading quota information…';
+  return quotas.map(({ provider, windows, error, email, plan }) => {
+    const name = provider === 'claude' ? 'Claude' : 'Codex';
+    const lines = error ? [error] : windows.length ? windows.map((w) => `${w.label}: ${w.usedPercent}% used${w.used != null && w.limit != null ? ` · ${w.currency} ${w.used.toFixed(2)} / ${w.limit.toFixed(2)}` : ''}${w.resetAt ? ` · resets ${w.resetAt}` : ''}`) : ['No quota windows available'];
+    const identity = [email, plan].filter(Boolean).join(' · ');
+    return `${name}${identity ? ` (${identity})` : ''}\n${lines.map((line) => `  ${line}`).join('\n')}`;
+  }).join('\n\n').replace(/[\x00-\x09\x0b-\x1f\x7f-\x9f]/g, '');
+}

package/src/render.js

@@ -72,9 +72,10 @@ export function fmtCompact(n) {
   return String(n);
 }
 
-export function fmtCost(n) {
+export function fmtCost(n, status) {
+  if (status === "unavailable") return "n/a";
   if (!n) return "—";
-  return "$" + Number(n).toFixed(2);
+  return (status === "estimated" || status === "partial" ? "~" : "") + "$" + Number(n).toFixed(2) + (status === "partial" ? "*" : "");
 }
 function fmtDuration(ms) {
   if (!ms || ms <= 0) return chalk.dim("—");
@@ -175,6 +176,7 @@ export function renderHeader({
   totalSessions,
   totalTokens,
   totalCost,
+  costStatus,
   dateRange,
 }) {
   const title = gradient.pastel.multiline("◆  AI TOKEN ANALYZER  ◆");
@@ -183,7 +185,7 @@ export function renderHeader({
     "  •  " +
     chalk.bold.cyan(`${fmtCompact(totalTokens)} total tokens`) +
     (totalCost
-      ? "  •  " + chalk.bold.yellow(`$${totalCost.toFixed(2)} USD`)
+      ? "  •  " + chalk.bold.yellow(`${fmtCost(totalCost, costStatus)} USD`)
       : "");
   const range =
     dateRange[0] && dateRange[1]
@@ -338,7 +340,7 @@ export function renderOverview(records, detections) {
       fmtInt(p.n),
       fmtCompact(p.tokensTotal),
       fmtCompact(p.avg),
-      fmtCost(p.cost),
+      fmtCost(p.cost, p.costStatus),
     ]);
   }
   pt.push([
@@ -346,7 +348,7 @@ export function renderOverview(records, detections) {
     chalk.bold(fmtInt(records.length)),
     chalk.bold(fmtCompact(t.tokensTotal)),
     chalk.bold(fmtCompact(t.avg)),
-    chalk.bold(fmtCost(t.cost)),
+    chalk.bold(fmtCost(t.cost, t.costStatus)),
   ]);
 
   const body =
@@ -354,7 +356,9 @@ export function renderOverview(records, detections) {
     "\n\n" +
     chalk.bold.underline("Token Breakdown") +
     "\n" +
-    bt.toString();
+    bt.toString() +
+    "\n\n" + chalk.dim("~ estimated API cost; * partial; n/a unavailable") +
+    (t.unknownModels.length ? "\n" + chalk.dim(`Unpriced models: ${t.unknownModels.map(m => String(m).replace(/[\x00-\x1f\x7f-\x9f]/g, "")).join(", ")}`) : "");
   return boxen(body, {
     title: chalk.bold("Overview"),
     borderStyle: "round",
@@ -526,7 +530,7 @@ export function renderProjectSessions(records, projectName) {
         colorize(r.tool, toolColor(r.tool)),
         dur,
         fmtCompact(r.tokensTotal),
-        r.cost ? "$" + r.cost.toFixed(4) : "—",
+        fmtCost(r.cost, r.costStatus),
         titleStr,
       ]);
     } else {
@@ -539,7 +543,7 @@ export function renderProjectSessions(records, projectName) {
         fmtCompact(r.tokensInput),
         fmtCompact(r.tokensOutput),
         fmtCompact(cache),
-        r.cost ? "$" + r.cost.toFixed(4) : "—",
+        fmtCost(r.cost, r.costStatus),
         titleStr,
       ]);
     }
@@ -600,7 +604,7 @@ export function renderPerTool(records) {
     }
     row.push(
       fmtCompact(p.tokensTotal),
-      fmtCost(p.cost),
+      fmtCost(p.cost, p.costStatus),
       fmtCompact(p.avg),
       bar(p.tokensTotal, max, barW),
     );
@@ -796,7 +800,7 @@ export function renderTopSessions(records, n = 5) {
         chalk.bold(String(i + 1)),
         chalk.bold.yellow(fmtCompact(r.tokensTotal)),
         `${fmtCompact(r.tokensInput)}/${fmtCompact(r.tokensOutput)}`,
-        r.cost ? "$" + r.cost.toFixed(4) : "—",
+        fmtCost(r.cost, r.costStatus),
         truncEnd(r.title, 30) || "—",
       ]);
     });
@@ -830,7 +834,7 @@ export function renderTopSessions(records, n = 5) {
       chalk.bold.yellow(fmtCompact(r.tokensTotal)),
       fmtCompact(r.tokensInput),
       fmtCompact(r.tokensOutput),
-      r.cost ? "$" + r.cost.toFixed(4) : "—",
+      fmtCost(r.cost, r.costStatus),
       shortModel(r.model),
       truncEnd(r.project, 30),
       truncEnd(r.title, 40) || "—",
@@ -850,6 +854,7 @@ export function renderTopSessions(records, n = 5) {
 
 export function renderNotes(detections, errors) {
   const lines = [];
+  lines.push(chalk.dim("Costs: ~ estimated API rates; * partial, excludes unpriced models; n/a unavailable."));
   lines.push(chalk.bold.underline("Token definitions"));
   lines.push(
     `  • ${chalk.cyan("Input")}        — prompt tokens (what was sent to the model)`,
@@ -861,7 +866,7 @@ export function renderNotes(detections, errors) {
     `  • ${chalk.cyan("Cache Read")}   — prompt tokens served from provider cache (cheap)`,
   );
   lines.push(
-    `  • ${chalk.cyan("Cache Write")}  — prompt tokens cached for future use (OpenCode only)`,
+    `  • ${chalk.cyan("Cache Write")}  — prompt tokens cached for future use`,
   );
   lines.push(
     `  • ${chalk.yellow("Reasoning")}    — extended thinking / chain-of-thought tokens`,

package/src/server.js

@@ -0,0 +1,67 @@
+import { createServer } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { detectAll } from './detectors.js';
+import { loadAll } from './loaders.js';
+
+const assets = new Map([
+  ['/', ['../web/index.html', 'text/html; charset=utf-8']],
+  ['/app.js', ['../web/app.js', 'text/javascript; charset=utf-8']],
+  ['/aggregate.js', ['./aggregate.js', 'text/javascript; charset=utf-8']],
+  ['/style.css', ['../web/style.css', 'text/css; charset=utf-8']],
+  ['/favicon.svg', ['../web/favicon.svg', 'image/svg+xml']],
+  ['/gsap.js', [import.meta.resolve('gsap/dist/gsap.min.js'), 'text/javascript; charset=utf-8']],
+  ['/fonts/manrope.woff2', ['../web/fonts/manrope.woff2', 'font/woff2']],
+  ['/icons/claude.svg', ['../web/icons/claude.svg', 'image/svg+xml']],
+  ['/icons/openai.svg', ['../web/icons/openai.svg', 'image/svg+xml']],
+  ['/icons/opencode.svg', ['../web/icons/opencode.svg', 'image/svg+xml']],
+]);
+
+export function createDashboardServer() {
+  return createServer(async (req, res) => {
+    const host = req.headers.host || '';
+    if (!/^127\.0\.0\.1:\d+$/.test(host) || (req.headers.origin && req.headers.origin !== `http://${host}`) || req.headers['sec-fetch-site'] === 'cross-site') {
+      res.writeHead(403).end('Forbidden');
+      return;
+    }
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    res.setHeader('Cache-Control', 'no-store');
+    res.setHeader('Content-Security-Policy', "default-src 'self'; style-src 'self'; script-src 'self'; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'");
+    if (req.method !== 'GET') {
+      res.writeHead(405, { Allow: 'GET' }).end();
+      return;
+    }
+    try {
+      const path = new URL(req.url, `http://${host}`).pathname;
+      if (path === '/api/usage') {
+        const detections = detectAll();
+        const { records, errors } = await loadAll(detections);
+        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' }).end(JSON.stringify({ detections, records, errors, generatedAt: new Date().toISOString() }));
+      } else if (assets.has(path)) {
+        const [file, type] = assets.get(path);
+        const content = await readFile(new URL(file, import.meta.url));
+        res.writeHead(200, { 'Content-Type': type }).end(content);
+      } else {
+        res.writeHead(404).end('Not found');
+      }
+    } catch {
+      res.writeHead(500, { 'Content-Type': 'application/json' }).end(JSON.stringify({ error: 'Could not load local usage data.' }));
+    }
+  });
+}
+
+export async function startDashboard() {
+  const server = createDashboardServer();
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  const url = `http://127.0.0.1:${server.address().port}/`;
+  console.log(`AI Usage Analyzer is running at ${url}\nPress Ctrl+C to stop.`);
+  const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+  const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+  child.on('error', () => {});
+  child.unref();
+  return server;
+}

package/src/tools.js

@@ -8,7 +8,7 @@
 // data, also wire a loader branch in src/loaders.js.
 
 import { statSync, readdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { homedir, platform } from 'node:os';
 import { env } from 'node:process';
 import { createRequire } from 'node:module';
@@ -112,10 +112,10 @@ export const TOOLS = [
     barChar: '▓',
     kind: 'jsonl-rollout',
     envVar: 'CODEX_HOME',
-    candidatePaths: () => [
-      env.CODEX_HOME || join(HOME, '.codex', 'sessions'),
-    ],
-    count: countJsonlRecursive,
+    candidatePaths: () => env.CODEX_HOME
+      ? [env.CODEX_HOME]
+      : [join(HOME, '.codex', 'sessions'), join(HOME, '.codex', 'archived_sessions')],
+    count: path => countJsonlRecursive(path) + (basename(path) === 'sessions' ? countJsonlRecursive(join(dirname(path), 'archived_sessions')) : 0),
     hasTokens: true,
     description: '~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl',
   },

package/src/tui.js

@@ -5,6 +5,7 @@ import chalk from "chalk";
 import process from "node:process";
 import readline from "node:readline";
 import { perProject } from "./aggregate.js";
+import { renderQuota } from "./quota.js";
 import {
     CURSOR_MARK,
     renderDetections,
@@ -25,11 +26,14 @@ function visLen(s) {
   return s.replace(ANSI_RE, "").length;
 }
 
-export async function runInteractive({ records, detections, errors, topN }) {
+export async function runInteractive({ records, detections, errors, topN, quotaPromise, quotaController, liveTailer }) {
   if (!process.stdout.isTTY || !process.stdin.isTTY) return false;
 
   const PROJECTS_VIEW = 1; // index into VIEWS
 
+  let liveRate = liveTailer ? liveTailer.tick() : null;
+  let quotas = null;
+  let active = true;
   const VIEWS = [
     {
       key: "1",
@@ -53,6 +57,7 @@ export async function runInteractive({ records, detections, errors, topN }) {
     },
     { key: "8", label: "Detections", fn: () => renderDetections(detections) },
     { key: "9", label: "Notes", fn: () => renderNotes(detections, errors) },
+    { key: "0", label: "Quota", fn: () => renderQuota(quotas) },
   ];
 
   // Project drill-down state (only active when current === PROJECTS_VIEW).
@@ -128,6 +133,7 @@ export async function runInteractive({ records, detections, errors, topN }) {
         "  ←/→ h/l switch  ↑/↓ j/k scroll  PgUp/PgDn  g/G top/bot  q quit",
       );
     }
+    if (liveRate !== null) hint = chalk.dim(` ${Math.round(liveRate)} tokens/min (10m) `) + hint;
     const gap = Math.max(1, w - visLen(hint) - visLen(pct));
     return chalk.bgBlack(hint + " ".repeat(gap) + pct);
   }
@@ -195,20 +201,29 @@ export async function runInteractive({ records, detections, errors, topN }) {
   process.stdout.write("\x1b[?1049h\x1b[?25l");
   draw(true);
 
-  process.stdout.on("resize", () => {
-    draw(true);
+  const liveTimer = liveTailer ? setInterval(() => { liveRate = liveTailer.tick(); if (active) draw(false); }, 5000) : null;
+  const onResize = () => draw(true);
+  process.stdout.on("resize", onResize);
+  if (quotaPromise) quotaPromise.then((result) => {
+    quotas = result;
+    if (active && current === 9) { loadView(); draw(false); }
   });
 
   return new Promise((resolve) => {
     function quit() {
       // Leave alternate screen — original terminal content is restored automatically.
+      active = false;
+      if (liveTimer) clearInterval(liveTimer);
+      quotaController?.abort();
+      process.stdout.removeListener("resize", onResize);
+      process.stdin.removeListener("keypress", onKeypress);
       process.stdout.write("\x1b[?25h\x1b[?1049l");
       process.stdin.setRawMode(false);
       process.stdin.pause();
-      resolve();
+      resolve(true);
     }
 
-    process.stdin.on("keypress", (_str, key) => {
+    function onKeypress(_str, key) {
       if (!key) return;
       const usable = usableRows();
       const maxScroll = Math.max(0, lines.length - usable);
@@ -270,8 +285,8 @@ export async function runInteractive({ records, detections, errors, topN }) {
           draw(false);
           return;
         }
-        if (_str && /^[1-9]$/.test(_str)) {
-          const idx = parseInt(_str, 10) - 1;
+        if (_str && /^[0-9]$/.test(_str)) {
+          const idx = _str === "0" ? 9 : parseInt(_str, 10) - 1;
           if (idx < VIEWS.length) {
             current = idx;
             if (current === PROJECTS_VIEW) proj.mode = "list";
@@ -305,6 +320,7 @@ export async function runInteractive({ records, detections, errors, topN }) {
       }
 
       if (moved) draw(false);
-    });
+    }
+    process.stdin.on("keypress", onKeypress);
   });
 }