tokmon 0.14.5 → 0.15.1

package/dist/chunk-ZPH4754N.js

@@ -0,0 +1,2542 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import { readFile, writeFile, mkdir, rename } from "fs/promises";
+import { join, isAbsolute } from "path";
+import { homedir } from "os";
+function envDir(name) {
+  const v = process.env[name];
+  return v && v.trim() && isAbsolute(v.trim()) ? v.trim() : void 0;
+}
+var DEFAULTS = {
+  interval: 2,
+  billingInterval: 5,
+  clearScreen: true,
+  timezone: null,
+  accounts: [],
+  activeAccountId: null,
+  disabledProviders: [],
+  onboarded: false,
+  dashboardLayout: "grid",
+  defaultFocus: "all",
+  ascii: "auto",
+  knownProviders: []
+};
+var LEGACY_KNOWN = ["claude", "codex", "cursor"];
+var ACCENT_COLORS = ["cyan", "magenta", "green", "yellow", "blue", "red"];
+function configDir() {
+  if (process.platform === "win32") {
+    return join(envDir("APPDATA") ?? join(homedir(), "AppData", "Roaming"), "tokmon");
+  }
+  return join(envDir("XDG_CONFIG_HOME") ?? join(homedir(), ".config"), "tokmon");
+}
+function configLocation() {
+  return join(configDir(), "config.json");
+}
+function cacheDir() {
+  if (process.platform === "win32") {
+    return join(envDir("LOCALAPPDATA") ?? envDir("APPDATA") ?? join(homedir(), "AppData", "Local"), "tokmon", "cache");
+  }
+  if (process.platform === "darwin") {
+    return join(homedir(), "Library", "Caches", "tokmon");
+  }
+  return join(envDir("XDG_CACHE_HOME") ?? join(homedir(), ".cache"), "tokmon");
+}
+var PROVIDER_IDS = ["claude", "codex", "cursor", "pi", "opencode", "copilot", "antigravity", "gemini"];
+function clampNum(v, fallback, min) {
+  return typeof v === "number" && Number.isFinite(v) && v >= min ? v : fallback;
+}
+async function loadConfig() {
+  let raw;
+  try {
+    raw = await readFile(configLocation(), "utf-8");
+  } catch {
+    return { ...DEFAULTS };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    try {
+      await writeFile(configLocation() + ".bak", raw);
+    } catch {
+    }
+    return { ...DEFAULTS };
+  }
+  try {
+    const accounts = (Array.isArray(parsed.accounts) ? parsed.accounts : []).map((a) => ({ ...a, providerId: a.providerId ?? "claude" })).filter((a) => typeof a?.id === "string" && typeof a?.name === "string" && PROVIDER_IDS.includes(a.providerId));
+    return {
+      ...DEFAULTS,
+      ...parsed,
+      interval: clampNum(parsed.interval, DEFAULTS.interval, 1),
+      billingInterval: clampNum(parsed.billingInterval, DEFAULTS.billingInterval, 1),
+      clearScreen: typeof parsed.clearScreen === "boolean" ? parsed.clearScreen : DEFAULTS.clearScreen,
+      timezone: typeof parsed.timezone === "string" && parsed.timezone.trim() ? parsed.timezone : null,
+      accounts,
+      activeAccountId: typeof parsed.activeAccountId === "string" ? parsed.activeAccountId : null,
+      disabledProviders: (Array.isArray(parsed.disabledProviders) ? parsed.disabledProviders : []).filter((p) => PROVIDER_IDS.includes(p)),
+      onboarded: parsed.onboarded === true,
+      dashboardLayout: parsed.dashboardLayout === "single" ? "single" : "grid",
+      defaultFocus: parsed.defaultFocus === "last" ? "last" : "all",
+      ascii: parsed.ascii === "on" ? "on" : parsed.ascii === "off" ? "off" : "auto",
+      knownProviders: Array.isArray(parsed.knownProviders) ? parsed.knownProviders.filter((p) => PROVIDER_IDS.includes(p)) : parsed.onboarded === true ? [...LEGACY_KNOWN] : []
+    };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+var saveQueue = Promise.resolve();
+function saveConfig(config) {
+  saveQueue = saveQueue.then(async () => {
+    try {
+      const dir = configDir();
+      await mkdir(dir, { recursive: true });
+      const tmp = join(dir, `config.json.${process.pid}.tmp`);
+      await writeFile(tmp, JSON.stringify(config, null, 2) + "\n");
+      await rename(tmp, configLocation());
+    } catch {
+    }
+  });
+  return saveQueue;
+}
+function slugify(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 48);
+}
+function generateAccountId(name, existing) {
+  const base = slugify(name) || "account";
+  const taken = new Set(existing.map((a) => a.id));
+  if (!taken.has(base)) return base;
+  for (let i = 2; i < 1e3; i++) {
+    const candidate = `${base}_${i}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+  return `${base}_${Date.now()}`;
+}
+function pickAccentColor(existing) {
+  const used = new Set(existing.map((a) => a.color).filter(Boolean));
+  for (const c of ACCENT_COLORS) {
+    if (!used.has(c)) return c;
+  }
+  return ACCENT_COLORS[existing.length % ACCENT_COLORS.length];
+}
+function expandHome(p) {
+  if (!p) return homedir();
+  if (p === "~" || p === "~/" || p === "~\\") return homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) return join(homedir(), p.slice(2));
+  return p;
+}
+
+// src/providers/usage-core.ts
+import { readFile as readFile2, writeFile as writeFile2, rename as rename2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/tz.ts
+function systemTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+function isValidTimezone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-CA", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveTimezone(cfg) {
+  if (!cfg) return systemTimezone();
+  return isValidTimezone(cfg) ? cfg : systemTimezone();
+}
+var dayFmtCache = /* @__PURE__ */ new Map();
+function dayFmt(tz) {
+  let f = dayFmtCache.get(tz);
+  if (!f) {
+    f = new Intl.DateTimeFormat("en-CA", {
+      timeZone: tz,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+    dayFmtCache.set(tz, f);
+  }
+  return f;
+}
+function dayKey(ts, tz) {
+  return dayFmt(tz).format(new Date(ts));
+}
+function monthKey(ts, tz) {
+  return dayKey(ts, tz).slice(0, 7);
+}
+var partsFmtCache = /* @__PURE__ */ new Map();
+function partsFmt(tz) {
+  let f = partsFmtCache.get(tz);
+  if (!f) {
+    f = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      weekday: "short"
+    });
+    partsFmtCache.set(tz, f);
+  }
+  return f;
+}
+var WEEKDAY_MAP = {
+  Sun: 0,
+  Mon: 1,
+  Tue: 2,
+  Wed: 3,
+  Thu: 4,
+  Fri: 5,
+  Sat: 6
+};
+function tzParts(ts, tz) {
+  const parts = partsFmt(tz).formatToParts(new Date(ts));
+  const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
+  return {
+    y: Number(get("year")),
+    m: Number(get("month")),
+    d: Number(get("day")),
+    hh: Number(get("hour")),
+    mm: Number(get("minute")),
+    ss: Number(get("second")),
+    weekday: WEEKDAY_MAP[get("weekday")] ?? 0
+  };
+}
+function instantFromTz(y, m, d, hh, mm, ss, tz) {
+  const guess = Date.UTC(y, m - 1, d, hh, mm, ss);
+  const r = tzParts(guess, tz);
+  const rendered = Date.UTC(r.y, r.m - 1, r.d, r.hh, r.mm, r.ss);
+  const offset = rendered - guess;
+  return guess - offset;
+}
+function startOfDay(ts, tz) {
+  const p = tzParts(ts, tz);
+  return instantFromTz(p.y, p.m, p.d, 0, 0, 0, tz);
+}
+function startOfMonth(ts, tz) {
+  const p = tzParts(ts, tz);
+  return instantFromTz(p.y, p.m, 1, 0, 0, 0, tz);
+}
+function startOfWeek(ts, tz) {
+  const p = tzParts(ts, tz);
+  const offset = p.weekday === 0 ? 6 : p.weekday - 1;
+  return instantFromTz(p.y, p.m, p.d - offset, 0, 0, 0, tz);
+}
+function monthsAgoStart(ts, months, tz) {
+  const p = tzParts(ts, tz);
+  return instantFromTz(p.y, p.m - months, 1, 0, 0, 0, tz);
+}
+function weekKey(ts, tz) {
+  return dayKey(startOfWeek(ts, tz), tz);
+}
+
+// src/providers/usage-core.ts
+var SPARK_DAYS = 14;
+var DAY_MS = 864e5;
+var CACHE_VERSION = 4;
+var STABLE_AGE_MS = 5 * 6e4;
+var PRUNE_AGE_MS = 200 * DAY_MS;
+var memCache = /* @__PURE__ */ new Map();
+var diskLoaded = false;
+var dirty = false;
+var flushTimer = null;
+function cacheFile() {
+  return join2(cacheDir(), `usage-v${CACHE_VERSION}.json`);
+}
+function encode(mtimeMs, size, entries) {
+  const mods = [];
+  const idx = /* @__PURE__ */ new Map();
+  const rows = entries.map((e) => {
+    let mi = idx.get(e.model);
+    if (mi === void 0) {
+      mi = mods.length;
+      mods.push(e.model);
+      idx.set(e.model, mi);
+    }
+    return [e.ts, mi, e.input, e.output, e.cacheCreate, e.cacheRead, e.cost, e.cacheSavings, e.id ?? 0];
+  });
+  return { m: mtimeMs, s: size, mods, rows };
+}
+function decode(s) {
+  const num = (x) => typeof x === "number" && Number.isFinite(x) && x >= 0 ? x : 0;
+  const out = [];
+  for (const r of s.rows) {
+    if (!Array.isArray(r) || r.length < 8) continue;
+    const ts = r[0];
+    if (typeof ts !== "number" || !Number.isFinite(ts)) continue;
+    const mi = r[1];
+    out.push({
+      ts,
+      model: typeof mi === "number" && typeof s.mods[mi] === "string" ? s.mods[mi] : "unknown",
+      input: num(r[2]),
+      output: num(r[3]),
+      cacheCreate: num(r[4]),
+      cacheRead: num(r[5]),
+      cost: num(r[6]),
+      cacheSavings: num(r[7]),
+      id: typeof r[8] === "string" ? r[8] : void 0
+    });
+  }
+  return out;
+}
+async function ensureDiskLoaded() {
+  if (diskLoaded) return;
+  diskLoaded = true;
+  try {
+    const obj = JSON.parse(await readFile2(cacheFile(), "utf-8"));
+    for (const [path, s] of Object.entries(obj)) {
+      if (s && typeof s.m === "number" && Array.isArray(s.rows) && Array.isArray(s.mods)) {
+        memCache.set(path, { mtimeMs: s.m, size: typeof s.s === "number" ? s.s : -1, entries: decode(s) });
+      }
+    }
+  } catch {
+  }
+}
+async function flushDisk() {
+  if (!dirty) return;
+  const now = Date.now();
+  const obj = {};
+  for (const [path, v] of memCache) {
+    if (now - v.mtimeMs > STABLE_AGE_MS && now - v.mtimeMs < PRUNE_AGE_MS) {
+      obj[path] = encode(v.mtimeMs, v.size, v.entries);
+    }
+  }
+  try {
+    await mkdir2(cacheDir(), { recursive: true });
+    const tmp = `${cacheFile()}.${process.pid}.tmp`;
+    await writeFile2(tmp, JSON.stringify(obj));
+    await rename2(tmp, cacheFile());
+    dirty = false;
+  } catch {
+  }
+}
+function scheduleFlush() {
+  if (flushTimer) return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    void flushDisk();
+  }, 4e3);
+  flushTimer.unref?.();
+}
+async function mapLimit(items, limit, fn) {
+  let i = 0;
+  const worker = async () => {
+    while (i < items.length) await fn(items[i++]);
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+}
+async function loadCachedEntries(files, parse, since) {
+  await ensureDiskLoaded();
+  const chunks = [];
+  await mapLimit(files, 8, async (f) => {
+    try {
+      let c = memCache.get(f.path);
+      if (!c || c.mtimeMs !== f.mtimeMs || c.size !== f.size) {
+        const entries = await parse(f.path);
+        c = { mtimeMs: f.mtimeMs, size: f.size, entries };
+        memCache.set(f.path, c);
+        if (Date.now() - f.mtimeMs > STABLE_AGE_MS) dirty = true;
+      }
+      chunks.push(c.entries);
+    } catch {
+    }
+  });
+  if (dirty) scheduleFlush();
+  return dedupe(chunks.flat().filter((e) => e.ts >= since));
+}
+function safeNum(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0;
+}
+function dedupe(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const e of entries) {
+    const k = e.id ?? `${e.ts} ${e.model} ${e.input} ${e.output} ${e.cacheCreate} ${e.cacheRead}`;
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(e);
+  }
+  return out;
+}
+function summarize(entries, tz) {
+  const now = Date.now();
+  const todayStart = startOfDay(now, tz);
+  const weekStart = startOfWeek(now, tz);
+  const monthStart = startOfMonth(now, tz);
+  const today = { cost: 0, tokens: 0, cacheRead: 0, cacheSavings: 0 };
+  const week = { cost: 0, tokens: 0, cacheRead: 0, cacheSavings: 0 };
+  const month = { cost: 0, tokens: 0, cacheRead: 0, cacheSavings: 0 };
+  const byDay = /* @__PURE__ */ new Map();
+  let oldestToday = now;
+  let hadToday = false;
+  const add = (s, e) => {
+    s.cost += e.cost;
+    s.tokens += e.input + e.output + e.cacheCreate + e.cacheRead;
+    s.cacheRead += e.cacheRead;
+    s.cacheSavings += e.cacheSavings;
+  };
+  for (const e of entries) {
+    if (e.ts >= monthStart) add(month, e);
+    if (e.ts >= weekStart) add(week, e);
+    if (e.ts >= todayStart) {
+      add(today, e);
+      hadToday = true;
+      if (e.ts < oldestToday) oldestToday = e.ts;
+    }
+    const dk = dayKey(e.ts, tz);
+    byDay.set(dk, (byDay.get(dk) ?? 0) + e.cost);
+  }
+  const hrs = Math.max((now - oldestToday) / 36e5, 1 / 60);
+  const burnRate = hadToday ? today.cost / hrs : 0;
+  const series = [];
+  for (let i = SPARK_DAYS - 1; i >= 0; i--) series.push(byDay.get(dayKey(now - i * DAY_MS, tz)) ?? 0);
+  return { today, week, month, burnRate, series };
+}
+function groupBy(entries, keyFn) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const key = keyFn(e);
+    const arr = groups.get(key);
+    if (arr) arr.push(e);
+    else groups.set(key, [e]);
+  }
+  const rows = [];
+  for (const [label, group] of groups) {
+    let input = 0, output = 0, cacheCreate = 0, cacheRead = 0, cacheSavings = 0, cost = 0, count = 0;
+    const byModel = /* @__PURE__ */ new Map();
+    for (const e of group) {
+      input += e.input;
+      output += e.output;
+      cacheCreate += e.cacheCreate;
+      cacheRead += e.cacheRead;
+      cacheSavings += e.cacheSavings;
+      cost += e.cost;
+      count += 1;
+      const m = byModel.get(e.model);
+      if (m) {
+        m.input += e.input;
+        m.output += e.output;
+        m.cacheCreate += e.cacheCreate;
+        m.cacheRead += e.cacheRead;
+        m.cacheSavings += e.cacheSavings;
+        m.cost += e.cost;
+        m.count += 1;
+      } else {
+        byModel.set(e.model, {
+          name: e.model,
+          input: e.input,
+          output: e.output,
+          cacheCreate: e.cacheCreate,
+          cacheRead: e.cacheRead,
+          cacheSavings: e.cacheSavings,
+          cost: e.cost,
+          count: 1
+        });
+      }
+    }
+    rows.push({
+      label,
+      models: [...byModel.keys()].sort(),
+      input,
+      output,
+      cacheCreate,
+      cacheRead,
+      cacheSavings,
+      total: input + output + cacheCreate + cacheRead,
+      cost,
+      count,
+      breakdown: [...byModel.values()].sort((a, b) => b.cost - a.cost)
+    });
+  }
+  return rows.sort((a, b) => a.label.localeCompare(b.label));
+}
+function tabulate(entries, tz) {
+  return {
+    daily: groupBy(entries, (e) => dayKey(e.ts, tz)),
+    weekly: groupBy(entries, (e) => weekKey(e.ts, tz)),
+    monthly: groupBy(entries, (e) => monthKey(e.ts, tz))
+  };
+}
+function mergeRows(groups) {
+  const byLabel = /* @__PURE__ */ new Map();
+  for (const rows of groups) {
+    for (const r of rows) {
+      const ex = byLabel.get(r.label);
+      if (!ex) {
+        byLabel.set(r.label, { ...r, models: [...r.models], breakdown: r.breakdown.map((m) => ({ ...m })) });
+        continue;
+      }
+      ex.input += r.input;
+      ex.output += r.output;
+      ex.cacheCreate += r.cacheCreate;
+      ex.cacheRead += r.cacheRead;
+      ex.cacheSavings += r.cacheSavings;
+      ex.total += r.total;
+      ex.cost += r.cost;
+      ex.count += r.count;
+      const bd = new Map(ex.breakdown.map((m) => [m.name, m]));
+      for (const m of r.breakdown) {
+        const e = bd.get(m.name);
+        if (e) {
+          e.input += m.input;
+          e.output += m.output;
+          e.cacheCreate += m.cacheCreate;
+          e.cacheRead += m.cacheRead;
+          e.cacheSavings += m.cacheSavings;
+          e.cost += m.cost;
+          e.count += m.count;
+        } else {
+          bd.set(m.name, { ...m });
+        }
+      }
+      ex.breakdown = [...bd.values()].sort((a, b) => b.cost - a.cost);
+      ex.models = [...bd.keys()].sort();
+    }
+  }
+  return [...byLabel.values()].sort((a, b) => a.label.localeCompare(b.label));
+}
+function mergeTables(list) {
+  return {
+    daily: mergeRows(list.map((t) => t.daily)),
+    weekly: mergeRows(list.map((t) => t.weekly)),
+    monthly: mergeRows(list.map((t) => t.monthly))
+  };
+}
+
+// src/format.ts
+function currency(value) {
+  if (!Number.isFinite(value) || value <= 0) return "$0.00";
+  if (value >= 1e4) {
+    return `$${value.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+  }
+  return `$${value.toFixed(2)}`;
+}
+function tokens(value) {
+  const v = Number.isFinite(value) && value > 0 ? value : 0;
+  if (v >= 1e9) return `${(v / 1e9).toFixed(1)}B`;
+  if (v >= 1e6) return `${(v / 1e6).toFixed(1)}M`;
+  if (v >= 1e3) return `${(v / 1e3).toFixed(1)}K`;
+  return String(Math.floor(v));
+}
+function time(date, tz) {
+  return date.toLocaleTimeString(void 0, {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    timeZone: tz
+  });
+}
+var SHORT_MONTHS = ["", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function shortDate(iso) {
+  const [, m, d] = iso.split("-");
+  return `${SHORT_MONTHS[Number(m)]} ${Number(d).toString().padStart(2, " ")}`;
+}
+function col(s, w, align = "right") {
+  if (s.length > w) return s.slice(0, w - 1) + "~";
+  const spaces = " ".repeat(w - s.length);
+  return align === "right" ? spaces + s : s + spaces;
+}
+function resetIn(iso) {
+  const diff = new Date(iso).getTime() - Date.now();
+  if (!Number.isFinite(diff) || diff <= 0) return "now";
+  const mins = Math.round(diff / 6e4);
+  if (mins < 60) return `${mins}m`;
+  const hrs = Math.floor(mins / 60);
+  const m = mins % 60;
+  if (hrs < 24) return `${hrs}h ${m}m`;
+  const days = Math.floor(hrs / 24);
+  const h = hrs % 24;
+  return `${days}d ${h}h`;
+}
+
+// src/providers/cursor/billing.ts
+import { access } from "fs/promises";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/http.ts
+async function readJson(res) {
+  const type = (res.headers.get("content-type") ?? "").toLowerCase();
+  if (type && !type.includes("json")) return null;
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+// src/providers/cursor/activity.ts
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/providers/cursor/sqlite.ts
+import { execFile as execFileCb } from "child_process";
+import { promisify } from "util";
+var execFile = promisify(execFileCb);
+var nativeDb;
+async function getNativeDb() {
+  if (nativeDb !== void 0) return nativeDb;
+  try {
+    nativeDb = (await import("sqlite")).DatabaseSync;
+  } catch {
+    nativeDb = null;
+  }
+  return nativeDb;
+}
+function classify(msg) {
+  if (/unable to open|no such file|cannot open|ENOENT/i.test(msg)) return "missing";
+  if (/database is (locked|busy)|readonly/i.test(msg)) return "locked";
+  if (/no such (function|table|column)|unknown option/i.test(msg)) return "old";
+  return "error";
+}
+async function runSqlite(db, sql, params = []) {
+  const DB = await getNativeDb();
+  if (DB) {
+    let handle;
+    try {
+      handle = new DB(db, { readOnly: true, timeout: 1500 });
+      const rows = handle.prepare(sql).all(...params);
+      return { status: "ok", rows };
+    } catch {
+    } finally {
+      try {
+        handle?.close();
+      } catch {
+      }
+    }
+  }
+  return runSqliteCli(db, sql, params);
+}
+function inlineParams(sql, params) {
+  let i = 0;
+  return sql.replace(/\?/g, () => {
+    const p = params[i++];
+    return typeof p === "number" ? String(p) : `'${String(p).replace(/'/g, "''")}'`;
+  });
+}
+async function runSqliteCli(db, sql, params) {
+  try {
+    const { stdout } = await execFile(
+      "sqlite3",
+      ["-readonly", "-json", "-cmd", ".timeout 1500", db, inlineParams(sql, params)],
+      { timeout: 1e4, maxBuffer: 8 << 20 }
+    );
+    const text = stdout.trim();
+    if (!text) return { status: "ok", rows: [] };
+    try {
+      return { status: "ok", rows: JSON.parse(text) };
+    } catch {
+      return { status: "error", rows: [] };
+    }
+  } catch (e) {
+    const err = e;
+    if (err?.code === "ENOENT") return { status: "missing", rows: [] };
+    return { status: classify(String(err?.stderr ?? err?.message ?? "")), rows: [] };
+  }
+}
+function sqliteStatusMessage(status) {
+  switch (status) {
+    case "missing":
+      return "Cursor data not found \u2014 open Cursor";
+    case "old":
+      return "Cursor DB unreadable";
+    case "locked":
+      return "Cursor DB busy \u2014 retrying next poll";
+    default:
+      return "Cursor data unavailable";
+  }
+}
+
+// src/providers/cursor/activity.ts
+var DAY_MS2 = 864e5;
+function trackingDb(homeDir) {
+  return join3(homeDir ?? homedir2(), ".cursor", "ai-tracking", "ai-code-tracking.db");
+}
+function localDayKey(ms) {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+async function cursorActivity(homeDir) {
+  const db = trackingDb(homeDir);
+  try {
+    const now = Date.now();
+    const res = await runSqlite(
+      db,
+      `SELECT date(createdAt/1000,'unixepoch','localtime') AS d, count(*) AS c FROM ai_code_hashes WHERE source!='human' AND createdAt >= ${Math.floor(now - 30 * DAY_MS2)} GROUP BY d;`
+    );
+    if (res.status !== "ok") return null;
+    const byDay = /* @__PURE__ */ new Map();
+    let month = 0;
+    for (const row of res.rows) {
+      const n = Number(row.c) || 0;
+      byDay.set(String(row.d), n);
+      month += n;
+    }
+    const series = [];
+    for (let i = SPARK_DAYS - 1; i >= 0; i--) series.push(byDay.get(localDayKey(now - i * DAY_MS2)) ?? 0);
+    if (month === 0 && series.every((v) => v === 0)) return null;
+    return { series, summary: `${tokens(month)} lines` };
+  } catch {
+    return null;
+  }
+}
+
+// src/providers/cursor/billing.ts
+var BASE = "https://api2.cursor.sh/aiserver.v1.DashboardService";
+var USAGE_URL = `${BASE}/GetCurrentPeriodUsage`;
+var PLAN_URL = `${BASE}/GetPlanInfo`;
+function cursorStateDb(homeDir) {
+  const base = homeDir ?? homedir3();
+  const tail = ["Cursor", "User", "globalStorage", "state.vscdb"];
+  if (process.platform === "darwin") {
+    return join4(base, "Library", "Application Support", ...tail);
+  }
+  if (process.platform === "win32") {
+    const roaming = homeDir ? join4(homeDir, "AppData", "Roaming") : envDir("APPDATA") ?? join4(base, "AppData", "Roaming");
+    return join4(roaming, ...tail);
+  }
+  const cfg = homeDir ? join4(homeDir, ".config") : envDir("XDG_CONFIG_HOME") ?? join4(base, ".config");
+  return join4(cfg, ...tail);
+}
+async function detectCursor(homeDir) {
+  try {
+    await access(cursorStateDb(homeDir));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readState(db, key) {
+  const r = await runSqlite(db, "SELECT value FROM ItemTable WHERE key=? LIMIT 1;", [key]);
+  const raw = r.status === "ok" ? r.rows[0]?.value : void 0;
+  return { value: typeof raw === "string" && raw.trim() ? raw.trim() : null, status: r.status };
+}
+async function connectPost(url, token) {
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1",
+        "User-Agent": "tokmon"
+      },
+      body: "{}",
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return { __status: res.status };
+    return await readJson(res);
+  } catch {
+    return null;
+  }
+}
+var dollars = (cents) => cents / 100;
+async function cursorBilling(account) {
+  const [core, activity, spend] = await Promise.all([
+    cursorBillingCore(account),
+    cursorActivity(account.homeDir),
+    cursorModelSpend(account.homeDir)
+  ]);
+  let merged = activity;
+  if (spend) {
+    const lines = activity?.summary ?? "";
+    const spendLabel = `$${Math.round(spend.total)} all-time`;
+    merged = {
+      series: activity?.series ?? [],
+      summary: lines ? `${lines} \xB7 ${spendLabel}` : spendLabel
+    };
+  }
+  return { ...core, activity: merged };
+}
+async function cursorBillingCore(account) {
+  const db = cursorStateDb(account.homeDir);
+  const [tokenRes, membershipRes] = await Promise.all([
+    readState(db, "cursorAuth/accessToken"),
+    readState(db, "cursorAuth/stripeMembershipType")
+  ]);
+  const token = tokenRes.value;
+  const membership = membershipRes.value;
+  const planFallback = membership ? membership.charAt(0).toUpperCase() + membership.slice(1) : null;
+  if (!token) {
+    const error = tokenRes.status === "ok" ? "Not signed in \u2014 open Cursor" : sqliteStatusMessage(tokenRes.status);
+    return { plan: planFallback, metrics: [], error };
+  }
+  const [usage, planInfo] = await Promise.all([
+    connectPost(USAGE_URL, token),
+    connectPost(PLAN_URL, token)
+  ]);
+  if (!usage || usage.__status) {
+    const expired = usage?.__status === 401 || usage?.__status === 403;
+    return { plan: planFallback, metrics: [], error: expired ? "Token expired \u2014 re-open Cursor" : "Cursor API error" };
+  }
+  const planName = planInfo?.planInfo?.planName ?? planFallback;
+  const price = planInfo?.planInfo?.price;
+  const plan = planName ? price ? `${planName} \xB7 ${price}` : planName : null;
+  const pu = usage.planUsage ?? {};
+  const metrics = [];
+  const rawEnd = usage.billingCycleEnd;
+  const endMs = typeof rawEnd === "string" && rawEnd.trim() ? Number(rawEnd) : NaN;
+  const resets = Number.isFinite(endMs) && endMs > 0 && endMs <= 864e13 ? resetIn(new Date(endMs).toISOString()) : null;
+  if (typeof pu.totalPercentUsed === "number" && typeof pu.limit === "number") {
+    metrics.push({
+      label: "Usage",
+      used: pu.totalPercentUsed,
+      limit: 100,
+      format: { kind: "percent" },
+      resetsAt: resets,
+      primary: true
+    });
+    const spentCents = typeof pu.totalSpend === "number" ? pu.totalSpend : pu.limit - (pu.remaining ?? 0);
+    metrics.push({
+      label: "Spend",
+      used: dollars(spentCents),
+      limit: dollars(pu.limit),
+      format: { kind: "dollars" }
+    });
+  }
+  if (pu.autoPercentUsed) {
+    metrics.push({ label: "Auto", used: pu.autoPercentUsed, limit: 100, format: { kind: "percent" } });
+  }
+  if (pu.apiPercentUsed) {
+    metrics.push({ label: "API", used: pu.apiPercentUsed, limit: 100, format: { kind: "percent" } });
+  }
+  const su = usage.spendLimitUsage;
+  if (su) {
+    const limitCents = su.individualLimit ?? su.pooledLimit ?? 0;
+    const remainingCents = su.individualRemaining ?? su.pooledRemaining ?? 0;
+    if (limitCents > 0) {
+      metrics.push({
+        label: "On-demand",
+        used: dollars(limitCents - remainingCents),
+        limit: dollars(limitCents),
+        format: { kind: "dollars" }
+      });
+    }
+  }
+  if (metrics.length === 0) {
+    return { plan, metrics: [], error: usage.enabled === false ? "No active subscription" : "No usage data" };
+  }
+  return { plan, metrics, error: null };
+}
+
+// src/providers/cursor/composer.ts
+async function cursorModelSpend(homeDir) {
+  const db = cursorStateDb(homeDir);
+  const sql = "SELECT mk.key AS name, sum(json_extract(mk.value,'$.costInCents')) AS cents, sum(json_extract(mk.value,'$.amount')) AS amt FROM cursorDiskKV c, json_each(c.value,'$.usageData') mk WHERE c.key LIKE 'composerData:%' AND json_valid(c.value) AND json_type(c.value,'$.usageData')='object' GROUP BY mk.key ORDER BY cents DESC;";
+  const res = await runSqlite(db, sql);
+  if (res.status !== "ok") return null;
+  const models = [];
+  let total = 0;
+  for (const row of res.rows) {
+    const usd = (Number(row.cents) || 0) / 100;
+    if (usd <= 0) continue;
+    models.push({ name: String(row.name ?? ""), usd, requests: Number(row.amt) || 0 });
+    total += usd;
+  }
+  if (total <= 0) return null;
+  return { total, models };
+}
+
+// src/providers/claude/usage.ts
+import { readdir, stat as fsStat, access as access2 } from "fs/promises";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { join as join5, isAbsolute as isAbsolute2 } from "path";
+import { homedir as homedir4 } from "os";
+var PRICING = {
+  "claude-opus-4-1": { i: 15e-6, o: 75e-6, cc: 1875e-8, cr: 15e-7 },
+  "claude-opus-4-0": { i: 15e-6, o: 75e-6, cc: 1875e-8, cr: 15e-7 },
+  "claude-opus-4-20250514": { i: 15e-6, o: 75e-6, cc: 1875e-8, cr: 15e-7 },
+  "claude-opus-4": { i: 5e-6, o: 25e-6, cc: 625e-8, cr: 5e-7 },
+  "claude-3-opus": { i: 15e-6, o: 75e-6, cc: 1875e-8, cr: 15e-7 },
+  "claude-sonnet-4": { i: 3e-6, o: 15e-6, cc: 375e-8, cr: 3e-7 },
+  "claude-haiku-4": { i: 1e-6, o: 5e-6, cc: 125e-8, cr: 1e-7 },
+  "claude-fable-5": { i: 1e-5, o: 5e-5, cc: 125e-7, cr: 1e-6 }
+};
+var PRICE_KEYS = Object.keys(PRICING).sort((a, b) => b.length - a.length);
+var FALLBACK = PRICING["claude-opus-4"];
+function claudeConfigDirs(homeDir) {
+  if (homeDir) {
+    return [join5(homeDir, ".claude"), join5(homeDir, ".config", "claude")];
+  }
+  const home = homedir4();
+  const dirs = [join5(home, ".claude")];
+  const xdg = envDir("XDG_CONFIG_HOME");
+  if (xdg) {
+    dirs.push(join5(xdg, "claude"));
+  } else if (process.platform !== "win32") {
+    dirs.push(join5(home, ".config", "claude"));
+  }
+  const appData = envDir("APPDATA");
+  if (appData) dirs.push(join5(appData, "claude"));
+  if (process.env.CLAUDE_CONFIG_DIR) {
+    for (const p of process.env.CLAUDE_CONFIG_DIR.split(process.platform === "win32" ? ";" : ",")) {
+      const t = p.trim();
+      if (t && isAbsolute2(t)) dirs.push(t);
+    }
+  }
+  return [...new Set(dirs)];
+}
+function getClaudeDirs(homeDir) {
+  return claudeConfigDirs(homeDir).map((d) => join5(d, "projects"));
+}
+async function detectClaude(homeDir) {
+  for (const dir of getClaudeDirs(homeDir)) {
+    try {
+      await access2(dir);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function priceFor(model) {
+  for (const key of PRICE_KEYS) {
+    if (!model.startsWith(key)) continue;
+    const rest = model.slice(key.length);
+    if (rest === "" || rest[0] === "-") return PRICING[key];
+  }
+  return FALLBACK;
+}
+function costOf(model, u) {
+  const p = priceFor(model);
+  return safeNum(u.input_tokens) * p.i + safeNum(u.output_tokens) * p.o + safeNum(u.cache_creation_input_tokens) * p.cc + safeNum(u.cache_read_input_tokens) * p.cr;
+}
+function shortModel(model) {
+  return model.replace("claude-", "").replace(/-\d{8}$/, "");
+}
+async function parseFile(path) {
+  const entries = [];
+  const rl = createInterface({ input: createReadStream(path), crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line.includes('"usage"')) continue;
+    try {
+      const obj = JSON.parse(line.charCodeAt(0) === 65279 ? line.slice(1) : line);
+      if (obj.type !== "assistant" || !obj.message?.usage) continue;
+      const ts = new Date(obj.timestamp ?? 0).getTime();
+      if (!Number.isFinite(ts)) continue;
+      const u = obj.message.usage;
+      const model = typeof obj.message.model === "string" && obj.message.model ? obj.message.model : "unknown";
+      const input = safeNum(u.input_tokens);
+      const output = safeNum(u.output_tokens);
+      const cacheCreate = safeNum(u.cache_creation_input_tokens);
+      const cacheRead = safeNum(u.cache_read_input_tokens);
+      if (input + output + cacheCreate + cacheRead === 0) continue;
+      const p = priceFor(model);
+      const msgId = obj.message?.id;
+      entries.push({
+        id: msgId ? msgId + (obj.requestId ? ":" + obj.requestId : "") : void 0,
+        ts,
+        model: shortModel(model),
+        cost: costOf(model, u),
+        input,
+        output,
+        cacheCreate,
+        cacheRead,
+        cacheSavings: cacheRead * (p.i - p.cr)
+      });
+    } catch {
+    }
+  }
+  return entries;
+}
+async function loadEntries(since, homeDir) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  const seenIno = /* @__PURE__ */ new Set();
+  for (const dir of getClaudeDirs(homeDir)) {
+    let listing;
+    try {
+      listing = await readdir(dir, { recursive: true });
+    } catch {
+      continue;
+    }
+    for (const f of listing) {
+      if (!f.endsWith(".jsonl")) continue;
+      const path = join5(dir, f);
+      if (seen.has(path)) continue;
+      seen.add(path);
+      try {
+        const s = await fsStat(path);
+        if (s.mtimeMs < since) continue;
+        if (s.ino && process.platform !== "win32") {
+          const idn = `${s.dev}:${s.ino}`;
+          if (seenIno.has(idn)) continue;
+          seenIno.add(idn);
+        }
+        files.push({ path, mtimeMs: s.mtimeMs, size: s.size });
+      } catch {
+      }
+    }
+  }
+  return loadCachedEntries(files, parseFile, since);
+}
+async function claudeDashboard(tz, homeDir) {
+  const now = Date.now();
+  const since = Math.min(startOfMonth(now, tz), startOfWeek(now, tz), now - SPARK_DAYS * 864e5);
+  const entries = await loadEntries(since, homeDir);
+  return summarize(entries, tz);
+}
+async function claudeTable(tz, homeDir) {
+  const entries = await loadEntries(monthsAgoStart(Date.now(), 6, tz), homeDir);
+  return tabulate(entries, tz);
+}
+
+// src/providers/claude/billing.ts
+import { execFile as execFileCb2 } from "child_process";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+import { promisify as promisify2 } from "util";
+var execFile2 = promisify2(execFileCb2);
+function parseAuth(raw) {
+  try {
+    const creds = JSON.parse(raw);
+    const o = creds?.claudeAiOauth ?? creds;
+    const token = o?.accessToken;
+    if (typeof token !== "string" || !token) return null;
+    return {
+      token,
+      subscriptionType: typeof o.subscriptionType === "string" ? o.subscriptionType : void 0,
+      rateLimitTier: typeof o.rateLimitTier === "string" ? o.rateLimitTier : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function readCredentialsFile(homeDir) {
+  for (const dir of claudeConfigDirs(homeDir)) {
+    try {
+      const auth = parseAuth(await readFile3(join6(dir, ".credentials.json"), "utf-8"));
+      if (auth) return auth;
+    } catch {
+    }
+  }
+  return null;
+}
+async function readMacKeychain() {
+  try {
+    const { stdout } = await execFile2("security", [
+      "find-generic-password",
+      "-s",
+      "Claude Code-credentials",
+      "-w"
+    ], { timeout: 5e3 });
+    return parseAuth(stdout.trim());
+  } catch {
+    return null;
+  }
+}
+async function getAuth(homeDir) {
+  const isDefault = !homeDir || homeDir === homedir5();
+  if (isDefault && process.platform === "darwin") {
+    const auth = await readMacKeychain();
+    if (auth) return auth;
+  }
+  return readCredentialsFile(homeDir);
+}
+function planLabel(auth) {
+  const sub = auth.subscriptionType;
+  if (!sub) return null;
+  const base = sub.charAt(0).toUpperCase() + sub.slice(1);
+  const tier = (auth.rateLimitTier ?? "").match(/(\d+)x/);
+  return tier ? `${base} ${tier[1]}x` : base;
+}
+var pct = (used, resets, primary) => ({ label: "", used, limit: 100, format: { kind: "percent" }, resetsAt: resets ?? null, primary });
+async function claudeBilling(account) {
+  const auth = await getAuth(account.homeDir);
+  if (!auth) return { plan: null, metrics: [], error: "No OAuth token \u2014 run claude and log in" };
+  const plan = planLabel(auth);
+  try {
+    const res = await fetch("https://api.anthropic.com/api/oauth/usage", {
+      headers: {
+        "Authorization": `Bearer ${auth.token}`,
+        "anthropic-beta": "oauth-2025-04-20",
+        "User-Agent": "tokmon"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (res.status === 429) return { plan, metrics: [], error: "Rate limited \u2014 retrying next poll" };
+    if (res.status === 401) return { plan, metrics: [], error: "Token expired \u2014 restart Claude Code" };
+    if (!res.ok) return { plan, metrics: [], error: `API ${res.status}` };
+    const data = await readJson(res);
+    if (!data) return { plan, metrics: [], error: "Unexpected API response" };
+    const metrics = [];
+    if (data.five_hour) {
+      metrics.push({ ...pct(data.five_hour.utilization, resetIn(data.five_hour.resets_at), true), label: "5h" });
+    }
+    if (data.seven_day) {
+      metrics.push({ ...pct(data.seven_day.utilization, resetIn(data.seven_day.resets_at)), label: "Week" });
+    }
+    if (data.seven_day_sonnet) {
+      metrics.push({ ...pct(data.seven_day_sonnet.utilization), label: "Sonnet" });
+    }
+    if (data.extra_usage?.is_enabled) {
+      metrics.push({
+        label: "Extra",
+        used: (data.extra_usage.used_credits ?? 0) / 100,
+        limit: data.extra_usage.monthly_limit != null ? data.extra_usage.monthly_limit / 100 : null,
+        format: { kind: "dollars", currency: data.extra_usage.currency ?? "USD" }
+      });
+    }
+    return { plan, metrics, error: null };
+  } catch {
+    return { plan, metrics: [], error: "Network error" };
+  }
+}
+
+// src/providers/claude/index.ts
+var claudeProvider = {
+  id: "claude",
+  name: "Claude",
+  color: "green",
+  hasUsage: true,
+  hasBilling: true,
+  detect: (homeDir) => detectClaude(homeDir),
+  fetchSummary: (account, tz) => claudeDashboard(tz, account.homeDir),
+  fetchTable: (account, tz) => claudeTable(tz, account.homeDir),
+  fetchBilling: (account) => claudeBilling(account)
+};
+
+// src/providers/codex/usage.ts
+import { readdir as readdir2, stat as fsStat2, access as access3 } from "fs/promises";
+import { createReadStream as createReadStream2 } from "fs";
+import { createInterface as createInterface2 } from "readline";
+import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
+var PRICING2 = {
+  "gpt-5-codex": { in: 125e-8, cr: 125e-9, out: 1e-5 },
+  "gpt-5-mini": { in: 25e-8, cr: 25e-9, out: 2e-6 },
+  "gpt-5-nano": { in: 5e-8, cr: 5e-9, out: 4e-7 },
+  "gpt-5": { in: 125e-8, cr: 125e-9, out: 1e-5 },
+  "o4-mini": { in: 11e-7, cr: 275e-9, out: 44e-7 }
+};
+var FALLBACK2 = PRICING2["gpt-5-codex"];
+var PRICE_KEYS2 = Object.keys(PRICING2).sort((a, b) => b.length - a.length);
+function codexHomes(homeDir) {
+  if (homeDir) return [join7(homeDir, ".codex")];
+  const homes = [];
+  const codexHome = envDir("CODEX_HOME");
+  if (codexHome) homes.push(codexHome);
+  homes.push(join7(homedir6(), ".codex"));
+  homes.push(join7(homedir6(), ".config", "codex"));
+  return [...new Set(homes)];
+}
+async function detectCodex(homeDir) {
+  for (const home of codexHomes(homeDir)) {
+    try {
+      await access3(join7(home, "sessions"));
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function priceFor2(model) {
+  const m = model.toLowerCase();
+  for (const key of PRICE_KEYS2) {
+    if (m.startsWith(key) || m.includes(key)) return PRICING2[key];
+  }
+  return FALLBACK2;
+}
+function extractModel(obj) {
+  const p = obj?.payload ?? obj;
+  return p?.model || p?.collaboration_mode?.settings?.model || p?.model_slug || p?.config?.model || p?.info?.model || null;
+}
+function subtractClamped(cur, prev) {
+  const sub = (a, b) => Math.max(0, (a ?? 0) - (b ?? 0));
+  return {
+    input_tokens: sub(cur.input_tokens, prev?.input_tokens),
+    cached_input_tokens: sub(cur.cached_input_tokens, prev?.cached_input_tokens),
+    output_tokens: sub(cur.output_tokens, prev?.output_tokens),
+    reasoning_output_tokens: sub(cur.reasoning_output_tokens, prev?.reasoning_output_tokens)
+  };
+}
+function eventSig(last, total) {
+  const f = (x) => x ? `${x.input_tokens ?? 0},${x.cached_input_tokens ?? 0},${x.output_tokens ?? 0},${x.reasoning_output_tokens ?? 0}` : "-";
+  return `${f(last)}|${f(total)}`;
+}
+async function parseFile2(path) {
+  const entries = [];
+  let model = "gpt-5-codex";
+  let prevTotal = null;
+  let prevSig = null;
+  const rl = createInterface2({ input: createReadStream2(path), crlfDelay: Infinity });
+  for await (const rawLine of rl) {
+    if (!rawLine.includes("token_count") && !rawLine.includes("turn_context")) continue;
+    try {
+      const line = rawLine.charCodeAt(0) === 65279 ? rawLine.slice(1) : rawLine;
+      const obj = JSON.parse(line);
+      const payloadType = obj?.payload?.type ?? obj?.type;
+      if (payloadType === "turn_context") {
+        const m = extractModel(obj);
+        if (typeof m === "string" && m.trim()) model = m;
+        continue;
+      }
+      if (payloadType !== "token_count") continue;
+      const info = obj?.payload?.info;
+      const total = info?.total_token_usage;
+      const last = info?.last_token_usage;
+      const sig = eventSig(last, total);
+      if (sig === prevSig) continue;
+      prevSig = sig;
+      let d = last;
+      if (!d && total) {
+        const reset = !!prevTotal && (total.input_tokens ?? 0) < (prevTotal.input_tokens ?? 0);
+        d = reset ? total : subtractClamped(total, prevTotal);
+      }
+      if (total) prevTotal = total;
+      if (!d) continue;
+      const ts = new Date(obj.timestamp ?? obj?.payload?.timestamp ?? 0).getTime();
+      if (!Number.isFinite(ts)) continue;
+      const inputTotal = safeNum(d.input_tokens);
+      const cached = Math.min(safeNum(d.cached_input_tokens), inputTotal);
+      const input = inputTotal - cached;
+      const output = safeNum(d.output_tokens);
+      if (input + output + cached === 0) continue;
+      const p = priceFor2(model);
+      entries.push({
+        ts,
+        model,
+        cost: input * p.in + cached * p.cr + output * p.out,
+        input,
+        output,
+        cacheCreate: 0,
+        cacheRead: cached,
+        cacheSavings: cached * (p.in - p.cr)
+      });
+    } catch {
+    }
+  }
+  return entries;
+}
+async function loadEntries2(since, homeDir) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  const seenIno = /* @__PURE__ */ new Set();
+  for (const home of codexHomes(homeDir)) {
+    const dir = join7(home, "sessions");
+    let listing;
+    try {
+      listing = await readdir2(dir, { recursive: true });
+    } catch {
+      continue;
+    }
+    for (const f of listing) {
+      if (!f.endsWith(".jsonl") || !f.includes("rollout-")) continue;
+      const path = join7(dir, f);
+      if (seen.has(path)) continue;
+      seen.add(path);
+      try {
+        const s = await fsStat2(path);
+        if (s.mtimeMs < since) continue;
+        if (s.ino && process.platform !== "win32") {
+          const idn = `${s.dev}:${s.ino}`;
+          if (seenIno.has(idn)) continue;
+          seenIno.add(idn);
+        }
+        files.push({ path, mtimeMs: s.mtimeMs, size: s.size });
+      } catch {
+      }
+    }
+  }
+  return loadCachedEntries(files, parseFile2, since);
+}
+async function codexDashboard(tz, homeDir) {
+  const now = Date.now();
+  const since = Math.min(startOfMonth(now, tz), startOfWeek(now, tz), now - SPARK_DAYS * 864e5);
+  const entries = await loadEntries2(since, homeDir);
+  return summarize(entries, tz);
+}
+async function codexTable(tz, homeDir) {
+  const entries = await loadEntries2(monthsAgoStart(Date.now(), 6, tz), homeDir);
+  return tabulate(entries, tz);
+}
+
+// src/providers/codex/billing.ts
+import { execFile as execFileCb3 } from "child_process";
+import { readFile as readFile4, readdir as readdir3, stat as fsStat3 } from "fs/promises";
+import { createReadStream as createReadStream3 } from "fs";
+import { createInterface as createInterface3 } from "readline";
+import { join as join8 } from "path";
+import { promisify as promisify3 } from "util";
+var execFile3 = promisify3(execFileCb3);
+var USAGE_URL2 = "https://chatgpt.com/backend-api/wham/usage";
+var CREDIT_USD_RATE = 0.04;
+async function readAuthFile(home) {
+  try {
+    const raw = await readFile4(join8(home, "auth.json"), "utf-8");
+    const auth = JSON.parse(raw);
+    const accessToken = auth?.tokens?.access_token;
+    if (!accessToken) return null;
+    return { accessToken, accountId: auth?.tokens?.account_id };
+  } catch {
+    return null;
+  }
+}
+async function readKeychainAuth() {
+  try {
+    const { stdout } = await execFile3("security", [
+      "find-generic-password",
+      "-s",
+      "Codex Auth",
+      "-w"
+    ], { timeout: 5e3 });
+    const auth = JSON.parse(stdout.trim());
+    const accessToken = auth?.tokens?.access_token;
+    if (!accessToken) return null;
+    return { accessToken, accountId: auth?.tokens?.account_id };
+  } catch {
+    return null;
+  }
+}
+async function getAuth2(homeDir) {
+  for (const home of codexHomes(homeDir)) {
+    const auth = await readAuthFile(home);
+    if (auth) return auth;
+  }
+  if (process.platform === "darwin") return readKeychainAuth();
+  return null;
+}
+function planLabel2(planType) {
+  if (typeof planType !== "string" || !planType.trim()) return null;
+  const p = planType.trim().toLowerCase();
+  if (p === "prolite") return "Pro 5x";
+  if (p === "pro") return "Pro 20x";
+  return planType.charAt(0).toUpperCase() + planType.slice(1);
+}
+function isoOrNull(ms) {
+  return Number.isFinite(ms) && Math.abs(ms) <= 864e13 ? new Date(ms).toISOString() : null;
+}
+function resetFrom(window) {
+  if (!window) return null;
+  let iso = null;
+  if (typeof window.reset_at === "number") iso = isoOrNull(window.reset_at * 1e3);
+  else if (typeof window.resets_at === "number") iso = isoOrNull(window.resets_at * 1e3);
+  else if (typeof window.reset_after_seconds === "number") iso = isoOrNull(Date.now() + window.reset_after_seconds * 1e3);
+  return iso ? resetIn(iso) : null;
+}
+function percentMetric(label, used, resets, primary) {
+  return { label, used, limit: 100, format: { kind: "percent" }, resetsAt: resets, primary };
+}
+async function liveBilling(auth) {
+  try {
+    const headers = {
+      "Authorization": `Bearer ${auth.accessToken}`,
+      "Accept": "application/json",
+      "User-Agent": "tokmon"
+    };
+    if (auth.accountId) headers["ChatGPT-Account-Id"] = auth.accountId;
+    const res = await fetch(USAGE_URL2, { headers, signal: AbortSignal.timeout(1e4) });
+    if (!res.ok) return null;
+    const data = await readJson(res);
+    if (!data) return null;
+    const metrics = [];
+    const rl = data.rate_limit ?? null;
+    const primary = rl?.primary_window ?? null;
+    const secondary = rl?.secondary_window ?? null;
+    const headerPct = (name) => {
+      const h = res.headers.get(name);
+      if (h === null || h.trim() === "") return void 0;
+      const n = Number(h);
+      return Number.isFinite(n) ? n : void 0;
+    };
+    const primaryPct = headerPct("x-codex-primary-used-percent") ?? primary?.used_percent;
+    const secondaryPct = headerPct("x-codex-secondary-used-percent") ?? secondary?.used_percent;
+    if (typeof primaryPct === "number") metrics.push(percentMetric("5h", primaryPct, resetFrom(primary), true));
+    if (typeof secondaryPct === "number") metrics.push(percentMetric("Week", secondaryPct, resetFrom(secondary)));
+    const balance = data?.credits?.balance;
+    if (typeof balance === "number" && balance >= 0) {
+      metrics.push({ label: "Credits", used: balance * CREDIT_USD_RATE, limit: null, format: { kind: "dollars" } });
+    }
+    if (metrics.length === 0) return null;
+    return { plan: planLabel2(data.plan_type), metrics, error: null };
+  } catch {
+    return null;
+  }
+}
+async function newestRolloutFile(homeDir) {
+  let best = null;
+  for (const home of codexHomes(homeDir)) {
+    const dir = join8(home, "sessions");
+    let listing;
+    try {
+      listing = await readdir3(dir, { recursive: true });
+    } catch {
+      continue;
+    }
+    for (const f of listing) {
+      if (!f.endsWith(".jsonl") || !f.includes("rollout-")) continue;
+      const path = join8(dir, f);
+      try {
+        const s = await fsStat3(path);
+        if (!best || s.mtimeMs > best.mtime) best = { path, mtime: s.mtimeMs };
+      } catch {
+      }
+    }
+  }
+  return best?.path ?? null;
+}
+async function snapshotBilling(homeDir) {
+  const path = await newestRolloutFile(homeDir);
+  if (!path) return null;
+  let last = null;
+  try {
+    const rl = createInterface3({ input: createReadStream3(path), crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (!line.includes("rate_limits")) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj?.payload?.rate_limits) last = obj.payload.rate_limits;
+      } catch {
+      }
+    }
+  } catch {
+    return null;
+  }
+  if (!last) return null;
+  const metrics = [];
+  if (typeof last.primary?.used_percent === "number") {
+    metrics.push(percentMetric("5h", last.primary.used_percent, resetFrom(last.primary), true));
+  }
+  if (typeof last.secondary?.used_percent === "number") {
+    metrics.push(percentMetric("Week", last.secondary.used_percent, resetFrom(last.secondary)));
+  }
+  const balance = last?.credits?.balance;
+  if (typeof balance === "number" && balance >= 0) {
+    metrics.push({ label: "Credits", used: balance * CREDIT_USD_RATE, limit: null, format: { kind: "dollars" } });
+  }
+  if (metrics.length === 0) return null;
+  return { plan: planLabel2(last.plan_type), metrics, error: null };
+}
+async function codexBilling(account) {
+  const auth = await getAuth2(account.homeDir);
+  if (auth) {
+    const live = await liveBilling(auth);
+    if (live) return live;
+  }
+  const snap = await snapshotBilling(account.homeDir);
+  if (snap) return snap;
+  return {
+    plan: null,
+    metrics: [],
+    error: auth ? "Usage API failed \u2014 run codex to refresh" : "Not logged in \u2014 run codex"
+  };
+}
+
+// src/providers/codex/index.ts
+var codexProvider = {
+  id: "codex",
+  name: "Codex",
+  color: "cyan",
+  hasUsage: true,
+  hasBilling: true,
+  detect: (homeDir) => detectCodex(homeDir),
+  fetchSummary: (account, tz) => codexDashboard(tz, account.homeDir),
+  fetchTable: (account, tz) => codexTable(tz, account.homeDir),
+  fetchBilling: (account) => codexBilling(account)
+};
+
+// src/providers/cursor/index.ts
+var cursorProvider = {
+  id: "cursor",
+  name: "Cursor",
+  color: "magenta",
+  hasUsage: false,
+  // Cursor exposes spend/limits, not a token history
+  hasBilling: true,
+  detect: (homeDir) => detectCursor(homeDir),
+  fetchBilling: (account) => cursorBilling(account)
+};
+
+// src/providers/pi/usage.ts
+import { readdir as readdir4, stat as fsStat4, access as access4 } from "fs/promises";
+import { createReadStream as createReadStream4 } from "fs";
+import { createInterface as createInterface4 } from "readline";
+import { join as join9 } from "path";
+import { homedir as homedir7 } from "os";
+function piSessionsDir(homeDir) {
+  return join9(homeDir ?? homedir7(), ".pi", "agent", "sessions");
+}
+async function detectPi(homeDir) {
+  try {
+    await access4(piSessionsDir(homeDir));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pos(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+}
+async function parseFile3(path) {
+  const entries = [];
+  const rl = createInterface4({ input: createReadStream4(path), crlfDelay: Infinity });
+  for await (const rawLine of rl) {
+    if (!rawLine.includes('"usage"')) continue;
+    try {
+      const line = rawLine.charCodeAt(0) === 65279 ? rawLine.slice(1) : rawLine;
+      const obj = JSON.parse(line);
+      if (obj?.type !== "message") continue;
+      const msg = obj.message;
+      if (msg?.role !== "assistant" || !msg?.usage) continue;
+      const u = msg.usage;
+      const ts = new Date(obj.timestamp ?? msg.timestamp ?? 0).getTime();
+      if (!Number.isFinite(ts)) continue;
+      const input = safeNum(u.input);
+      const output = safeNum(u.output);
+      const cacheRead = safeNum(u.cacheRead);
+      const cacheCreate = safeNum(u.cacheWrite);
+      if (input + output + cacheRead + cacheCreate === 0) continue;
+      const c = u.cost ?? {};
+      const costInput = pos(c.input);
+      const cacheSavings = input > 0 && cacheRead > 0 ? Math.max(0, cacheRead * (costInput / input) - pos(c.cacheRead)) : 0;
+      const model = typeof msg.responseModel === "string" && msg.responseModel || typeof msg.model === "string" && msg.model || "unknown";
+      entries.push({
+        ts,
+        model,
+        cost: pos(c.total),
+        input,
+        output,
+        cacheCreate,
+        cacheRead,
+        cacheSavings
+      });
+    } catch {
+    }
+  }
+  return entries;
+}
+async function loadEntries3(since, homeDir) {
+  const dir = piSessionsDir(homeDir);
+  const files = [];
+  const seenIno = /* @__PURE__ */ new Set();
+  let listing;
+  try {
+    listing = await readdir4(dir, { recursive: true });
+  } catch {
+    return [];
+  }
+  for (const f of listing) {
+    if (!f.endsWith(".jsonl")) continue;
+    const path = join9(dir, f);
+    try {
+      const s = await fsStat4(path);
+      if (s.mtimeMs < since) continue;
+      if (s.ino && process.platform !== "win32") {
+        const idn = `${s.dev}:${s.ino}`;
+        if (seenIno.has(idn)) continue;
+        seenIno.add(idn);
+      }
+      files.push({ path, mtimeMs: s.mtimeMs, size: s.size });
+    } catch {
+    }
+  }
+  return loadCachedEntries(files, parseFile3, since);
+}
+async function piDashboard(tz, homeDir) {
+  const now = Date.now();
+  const since = Math.min(startOfMonth(now, tz), startOfWeek(now, tz), now - SPARK_DAYS * 864e5);
+  return summarize(await loadEntries3(since, homeDir), tz);
+}
+async function piTable(tz, homeDir) {
+  return tabulate(await loadEntries3(monthsAgoStart(Date.now(), 6, tz), homeDir), tz);
+}
+
+// src/providers/pi/index.ts
+var piProvider = {
+  id: "pi",
+  name: "Pi",
+  color: "blue",
+  hasUsage: true,
+  hasBilling: false,
+  detect: (homeDir) => detectPi(homeDir),
+  fetchSummary: (account, tz) => piDashboard(tz, account.homeDir),
+  fetchTable: (account, tz) => piTable(tz, account.homeDir)
+};
+
+// src/providers/opencode/usage.ts
+import { access as access5 } from "fs/promises";
+import { join as join10 } from "path";
+import { homedir as homedir8 } from "os";
+function opencodeDbPaths(homeDir) {
+  const base = homeDir ?? homedir8();
+  const paths = [];
+  if (!homeDir && process.env.XDG_DATA_HOME) paths.push(join10(process.env.XDG_DATA_HOME, "opencode", "opencode.db"));
+  paths.push(join10(base, ".local", "share", "opencode", "opencode.db"));
+  if (process.platform === "darwin") paths.push(join10(base, "Library", "Application Support", "opencode", "opencode.db"));
+  if (process.platform === "win32") {
+    const lad = homeDir ? join10(homeDir, "AppData", "Local") : process.env.LOCALAPPDATA;
+    if (lad) paths.push(join10(lad, "opencode", "opencode.db"));
+  }
+  return [...new Set(paths)];
+}
+async function findDb(homeDir) {
+  for (const p of opencodeDbPaths(homeDir)) {
+    try {
+      await access5(p);
+      return p;
+    } catch {
+    }
+  }
+  return null;
+}
+async function detectOpencode(homeDir) {
+  return await findDb(homeDir) !== null;
+}
+var pos2 = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+async function loadEntries4(since, homeDir) {
+  const db = await findDb(homeDir);
+  if (!db) return [];
+  const sql = "SELECT time_created AS ts, json_extract(data,'$.modelID') AS model, json_extract(data,'$.cost') AS cost, json_extract(data,'$.tokens.input') AS input, json_extract(data,'$.tokens.output') AS output, json_extract(data,'$.tokens.reasoning') AS reasoning, json_extract(data,'$.tokens.cache.read') AS cacheRead, json_extract(data,'$.tokens.cache.write') AS cacheWrite FROM message WHERE json_valid(data) AND json_extract(data,'$.role')='assistant' AND json_type(data,'$.tokens')='object' AND time_created >= ?;";
+  const res = await runSqlite(db, sql, [Math.floor(since)]);
+  if (res.status !== "ok") return [];
+  const entries = [];
+  for (const row of res.rows) {
+    const ts = pos2(row.ts);
+    if (!ts) continue;
+    const input = pos2(row.input);
+    const output = pos2(row.output);
+    const cacheRead = pos2(row.cacheRead);
+    const cacheCreate = pos2(row.cacheWrite);
+    if (input + output + cacheRead + cacheCreate === 0) continue;
+    entries.push({
+      ts,
+      model: typeof row.model === "string" && row.model ? row.model : "unknown",
+      cost: pos2(row.cost),
+      input,
+      output,
+      cacheCreate,
+      cacheRead,
+      cacheSavings: 0
+    });
+  }
+  return entries;
+}
+async function opencodeDashboard(tz, homeDir) {
+  const now = Date.now();
+  const since = Math.min(startOfMonth(now, tz), startOfWeek(now, tz), now - SPARK_DAYS * 864e5);
+  return summarize(await loadEntries4(since, homeDir), tz);
+}
+async function opencodeTable(tz, homeDir) {
+  return tabulate(await loadEntries4(monthsAgoStart(Date.now(), 6, tz), homeDir), tz);
+}
+
+// src/providers/opencode/index.ts
+var opencodeProvider = {
+  id: "opencode",
+  name: "opencode",
+  color: "yellow",
+  hasUsage: true,
+  hasBilling: false,
+  detect: (homeDir) => detectOpencode(homeDir),
+  fetchSummary: (account, tz) => opencodeDashboard(tz, account.homeDir),
+  fetchTable: (account, tz) => opencodeTable(tz, account.homeDir)
+};
+
+// src/providers/copilot/billing.ts
+import { execFile as execFileCb4 } from "child_process";
+import { access as access6, readFile as readFile5, readdir as readdir5 } from "fs/promises";
+import { join as join11 } from "path";
+import { homedir as homedir9 } from "os";
+import { promisify as promisify4 } from "util";
+var execFile4 = promisify4(execFileCb4);
+var USAGE_URL3 = "https://api.github.com/copilot_internal/user";
+var GH_KEYCHAIN_SERVICE = "gh:github.com";
+var GO_KEYRING_PREFIX = "go-keyring-base64:";
+function ghConfigDir(homeDir) {
+  if (!homeDir) {
+    const explicit = process.env.GH_CONFIG_DIR;
+    if (explicit && explicit.trim()) return explicit.trim();
+    if (process.platform === "win32") {
+      return join11(envDir("APPDATA") ?? join11(homedir9(), "AppData", "Roaming"), "GitHub CLI");
+    }
+    const xdg = envDir("XDG_CONFIG_HOME");
+    return xdg ? join11(xdg, "gh") : join11(homedir9(), ".config", "gh");
+  }
+  return process.platform === "win32" ? join11(homeDir, "AppData", "Roaming", "GitHub CLI") : join11(homeDir, ".config", "gh");
+}
+function ghHostsPath(homeDir) {
+  return join11(ghConfigDir(homeDir), "hosts.yml");
+}
+async function detectCopilot(homeDir) {
+  try {
+    await access6(ghHostsPath(homeDir));
+    return true;
+  } catch {
+  }
+  try {
+    await execFile4("gh", ["--version"], { timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function unquoteYamlValue(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function tokenFromHostsYaml(raw) {
+  const lines = raw.split(/\r?\n/);
+  let inGithub = false;
+  let githubIndent = -1;
+  for (const line of lines) {
+    const match = line.match(/^(\s*)([^:#][^:]*):\s*(.*)$/);
+    if (!match) continue;
+    const indent = match[1].length;
+    const key = match[2].trim();
+    const value = match[3].trim();
+    if (indent === 0) {
+      inGithub = key === "github.com";
+      githubIndent = inGithub ? indent : -1;
+      continue;
+    }
+    if (inGithub && indent > githubIndent && key === "oauth_token" && value) {
+      return unquoteYamlValue(value);
+    }
+  }
+  return null;
+}
+async function loadTokenFromHosts(homeDir) {
+  try {
+    const token = tokenFromHostsYaml(await readFile5(ghHostsPath(homeDir), "utf-8"));
+    return token ? { token, source: "gh-hosts" } : null;
+  } catch {
+    return null;
+  }
+}
+async function readMacKeychainService(service) {
+  if (process.platform !== "darwin") return null;
+  try {
+    const { stdout } = await execFile4("security", [
+      "find-generic-password",
+      "-s",
+      service,
+      "-w"
+    ], { timeout: 5e3 });
+    const raw = stdout.trim();
+    if (!raw) return null;
+    if (raw.startsWith(GO_KEYRING_PREFIX)) {
+      return Buffer.from(raw.slice(GO_KEYRING_PREFIX.length), "base64").toString("utf-8");
+    }
+    return raw;
+  } catch {
+    return null;
+  }
+}
+async function loadTokenFromGhKeychain() {
+  const token = await readMacKeychainService(GH_KEYCHAIN_SERVICE);
+  return token ? { token, source: "gh-keychain" } : null;
+}
+function vscodeUserDir(homeDir) {
+  const home = homeDir ?? homedir9();
+  if (process.platform === "darwin") return join11(home, "Library", "Application Support", "Code", "User");
+  if (process.platform === "win32") return join11(home, "AppData", "Roaming", "Code", "User");
+  return join11(home, ".config", "Code", "User");
+}
+function tokenFromText(raw) {
+  const patterns = [
+    /github\.com[^A-Za-z0-9_]+oauth_token[^A-Za-z0-9_]+([A-Za-z0-9_]{20,})/i,
+    /github\.com[^A-Za-z0-9_]+(gh[opusr]_[A-Za-z0-9_]{20,})/i,
+    /\b(gh[opusr]_[A-Za-z0-9_]{20,})\b/
+  ];
+  for (const pattern of patterns) {
+    const token = raw.match(pattern)?.[1];
+    if (token) return token;
+  }
+  return null;
+}
+async function loadTokenFromVsCode(homeDir) {
+  const userDir = vscodeUserDir(homeDir);
+  const candidates = [
+    join11(userDir, "globalStorage", "github.copilot-chat", "auth.json"),
+    join11(userDir, "globalStorage", "github.copilot", "auth.json"),
+    join11(userDir, "globalStorage", "state.vscdb")
+  ];
+  try {
+    for (const dirent of await readdir5(join11(userDir, "globalStorage"), { withFileTypes: true })) {
+      if (dirent.isDirectory() && dirent.name.toLowerCase().includes("github")) {
+        candidates.push(join11(userDir, "globalStorage", dirent.name, "auth.json"));
+      }
+    }
+  } catch {
+  }
+  for (const path of candidates) {
+    try {
+      const token = tokenFromText(await readFile5(path, "utf-8"));
+      if (token) return { token, source: "vscode" };
+    } catch {
+    }
+  }
+  return null;
+}
+async function loadToken(homeDir) {
+  return await loadTokenFromHosts(homeDir) || await loadTokenFromGhKeychain() || await loadTokenFromVsCode(homeDir);
+}
+function redactToken(token) {
+  return token.length <= 4 ? "****" : `****${token.slice(-4)}`;
+}
+function resetDate(value) {
+  return typeof value === "string" && value.trim() ? resetIn(value) : null;
+}
+function percentMetric2(label, snapshot, reset, primary) {
+  if (!snapshot || typeof snapshot.percent_remaining !== "number") return null;
+  if (snapshot.unlimited === true || snapshot.entitlement === 0) return null;
+  const used = Math.min(100, Math.max(0, 100 - snapshot.percent_remaining));
+  return { label, used, limit: 100, format: { kind: "percent" }, resetsAt: reset, primary };
+}
+function countMetric(label, remaining, total, reset) {
+  if (typeof remaining !== "number" || typeof total !== "number" || total <= 0) return null;
+  return {
+    label,
+    used: Math.max(0, total - remaining),
+    limit: total,
+    format: { kind: "count" },
+    resetsAt: reset
+  };
+}
+async function fetchUsage(token) {
+  try {
+    const res = await fetch(USAGE_URL3, {
+      headers: {
+        "Authorization": `token ${token}`,
+        "Accept": "application/json",
+        "Editor-Version": "vscode/1.96.2",
+        "Editor-Plugin-Version": "copilot-chat/0.26.7",
+        "User-Agent": "GitHubCopilotChat/0.26.7",
+        "X-Github-Api-Version": "2025-04-01"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return { data: null, status: res.status };
+    return { data: await readJson(res), status: res.status };
+  } catch {
+    return { data: null, status: null };
+  }
+}
+async function copilotBilling(account) {
+  const cred = await loadToken(account.homeDir);
+  if (!cred) return { plan: null, metrics: [], error: "Not logged in \u2014 run gh auth login" };
+  const { data, status } = await fetchUsage(cred.token);
+  if (!data) {
+    if (status === 401 || status === 403) {
+      return { plan: null, metrics: [], error: `Token invalid (${redactToken(cred.token)}) \u2014 run gh auth login` };
+    }
+    if (status) return { plan: null, metrics: [], error: `Copilot API ${status}` };
+    return { plan: null, metrics: [], error: "Network error" };
+  }
+  const plan = typeof data.copilot_plan === "string" && data.copilot_plan.trim() ? data.copilot_plan : null;
+  const metrics = [];
+  const quotaReset = resetDate(data.quota_reset_date);
+  const snapshots = data.quota_snapshots;
+  const premium = percentMetric2("Premium", snapshots?.premium_interactions, quotaReset, true);
+  if (premium) metrics.push(premium);
+  const chat = percentMetric2("Chat", snapshots?.chat, quotaReset);
+  if (chat) metrics.push(chat);
+  if (data.limited_user_quotas && data.monthly_quotas) {
+    const reset = resetDate(data.limited_user_reset_date);
+    const limitedChat = countMetric("Chat", data.limited_user_quotas.chat, data.monthly_quotas.chat, reset);
+    if (limitedChat) metrics.push(limitedChat);
+    const completions = countMetric("Completions", data.limited_user_quotas.completions, data.monthly_quotas.completions, reset);
+    if (completions) metrics.push(completions);
+  }
+  if (metrics.length === 0) return { plan, metrics: [], error: "No usage data" };
+  return { plan, metrics, error: null };
+}
+
+// src/providers/copilot/index.ts
+var copilotProvider = {
+  id: "copilot",
+  name: "Copilot",
+  color: "white",
+  hasUsage: false,
+  hasBilling: true,
+  detect: (homeDir) => detectCopilot(homeDir),
+  fetchBilling: (account) => copilotBilling(account)
+};
+
+// src/providers/antigravity/billing.ts
+import { access as access7, readdir as readdir7 } from "fs/promises";
+import { join as join13 } from "path";
+import { homedir as homedir11 } from "os";
+
+// src/providers/cloud-code.ts
+import { readFile as readFile6, readdir as readdir6, realpath, stat } from "fs/promises";
+import { spawnSync } from "child_process";
+import { homedir as homedir10 } from "os";
+import { dirname, join as join12 } from "path";
+var CLOUD_CODE_URLS = [
+  "https://daily-cloudcode-pa.googleapis.com",
+  "https://cloudcode-pa.googleapis.com"
+];
+var LOAD_CODE_ASSIST_PATH = "/v1internal:loadCodeAssist";
+var FETCH_MODELS_PATH = "/v1internal:fetchAvailableModels";
+var RETRIEVE_QUOTA_PATH = "/v1internal:retrieveUserQuota";
+var GOOGLE_OAUTH_URL = "https://oauth2.googleapis.com/token";
+var GOOGLE_OAUTH_CLIENT_REGEX = /OAUTH_CLIENT_ID\s*=\s*["']([0-9]{6,}-[a-z0-9]+\.apps\.googleusercontent\.com)["']\s*;?\s*(?:var|const|let)?\s*OAUTH_CLIENT_SECRET\s*=\s*["'](GOCSPX-[A-Za-z0-9_-]+)["']/s;
+var MAX_BUNDLE_READ = 32 * 1024 * 1024;
+var cachedClient;
+var OAUTH_TOKEN_KEY = "antigravityUnifiedStateSync.oauthToken";
+var OAUTH_TOKEN_SENTINEL = "oauthTokenInfoSentinelKey";
+var CC_MODEL_BLACKLIST = {
+  MODEL_CHAT_20706: true,
+  MODEL_CHAT_23310: true,
+  MODEL_GOOGLE_GEMINI_2_5_FLASH: true,
+  MODEL_GOOGLE_GEMINI_2_5_FLASH_THINKING: true,
+  MODEL_GOOGLE_GEMINI_2_5_FLASH_LITE: true,
+  MODEL_GOOGLE_GEMINI_2_5_PRO: true,
+  MODEL_PLACEHOLDER_M19: true,
+  MODEL_PLACEHOLDER_M9: true,
+  MODEL_PLACEHOLDER_M12: true
+};
+function readVarint(bytes, start) {
+  let value = 0;
+  let shift = 0;
+  let pos3 = start;
+  while (pos3 < bytes.length) {
+    const b = bytes[pos3++];
+    value += (b & 127) * Math.pow(2, shift);
+    if ((b & 128) === 0) return { value, pos: pos3 };
+    shift += 7;
+  }
+  return null;
+}
+function readFields(bytes) {
+  const fields = {};
+  let pos3 = 0;
+  while (pos3 < bytes.length) {
+    const tag = readVarint(bytes, pos3);
+    if (!tag) break;
+    pos3 = tag.pos;
+    const fieldNum = Math.floor(tag.value / 8);
+    const wireType = tag.value % 8;
+    if (wireType === 0) {
+      const val = readVarint(bytes, pos3);
+      if (!val) break;
+      fields[fieldNum] = { type: 0, value: val.value };
+      pos3 = val.pos;
+    } else if (wireType === 1) {
+      if (pos3 + 8 > bytes.length) break;
+      pos3 += 8;
+    } else if (wireType === 2) {
+      const len = readVarint(bytes, pos3);
+      if (!len) break;
+      pos3 = len.pos;
+      if (pos3 + len.value > bytes.length) break;
+      fields[fieldNum] = { type: 2, data: bytes.slice(pos3, pos3 + len.value) };
+      pos3 += len.value;
+    } else if (wireType === 5) {
+      if (pos3 + 4 > bytes.length) break;
+      pos3 += 4;
+    } else {
+      break;
+    }
+  }
+  return fields;
+}
+function utf8(data) {
+  return Buffer.from(data).toString("utf8");
+}
+function decodeBase64(text) {
+  try {
+    return Buffer.from(text, "base64");
+  } catch {
+    return null;
+  }
+}
+function unwrapKeyringBase64(raw) {
+  const text = raw.trim();
+  if (!text.startsWith("go-keyring-base64:")) return text;
+  const decoded = decodeBase64(text.slice("go-keyring-base64:".length));
+  return decoded ? utf8(decoded).trim() : text;
+}
+function unwrapOAuthSentinel(base64Text) {
+  const outerBytes = decodeBase64(unwrapKeyringBase64(base64Text));
+  if (!outerBytes) return null;
+  const outer = readFields(outerBytes);
+  if (outer[1]?.type !== 2 || !outer[1].data) return null;
+  const wrapper = readFields(outer[1].data);
+  const sentinel = wrapper[1]?.type === 2 && wrapper[1].data ? utf8(wrapper[1].data) : null;
+  const payload = wrapper[2]?.type === 2 ? wrapper[2].data : null;
+  if (sentinel !== OAUTH_TOKEN_SENTINEL || !payload) return null;
+  const payloadFields = readFields(payload);
+  if (payloadFields[1]?.type !== 2 || !payloadFields[1].data) return null;
+  const innerText = utf8(payloadFields[1].data).trim();
+  return innerText ? decodeBase64(innerText) : null;
+}
+async function readAntigravityOAuthToken(db) {
+  const r = await runSqlite(db, "SELECT value FROM ItemTable WHERE key=? LIMIT 1;", [OAUTH_TOKEN_KEY]);
+  if (r.status !== "ok") return { token: null, status: r.status };
+  const raw = r.rows[0]?.value;
+  if (typeof raw !== "string" || !raw.trim()) return { token: null, status: "ok" };
+  const inner = unwrapOAuthSentinel(raw);
+  if (!inner) return { token: null, status: "ok" };
+  const fields = readFields(inner);
+  const accessToken = fields[1]?.type === 2 && fields[1].data ? utf8(fields[1].data) : null;
+  const refreshToken = fields[3]?.type === 2 && fields[3].data ? utf8(fields[3].data) : null;
+  let expirySeconds = null;
+  if (fields[4]?.type === 2 && fields[4].data) {
+    const ts = readFields(fields[4].data);
+    expirySeconds = ts[1]?.type === 0 && typeof ts[1].value === "number" ? ts[1].value : null;
+  }
+  if (!accessToken && !refreshToken) return { token: null, status: "ok" };
+  return { token: { accessToken, refreshToken, expirySeconds }, status: "ok" };
+}
+function redact(token) {
+  if (!token) return "none";
+  return `...${token.slice(-4)}`;
+}
+function geminiBundleCandidates() {
+  const candidates = [];
+  const addBundle = (nodeModulesRoot) => {
+    if (!nodeModulesRoot) return;
+    candidates.push(join12(nodeModulesRoot, "@google", "gemini-cli", "bundle"));
+  };
+  try {
+    const which = spawnSync("command", ["-v", "gemini"], { encoding: "utf8", timeout: 5e3 });
+    const resolved = typeof which.stdout === "string" ? which.stdout.trim().split("\n")[0]?.trim() : "";
+    if (resolved) candidates.push(resolved);
+  } catch {
+  }
+  const home = homedir10();
+  addBundle("/opt/homebrew/lib/node_modules");
+  addBundle("/usr/local/lib/node_modules");
+  addBundle(join12(home, ".local", "share", "node_modules"));
+  addBundle(join12(home, ".bun", "install", "global", "node_modules"));
+  try {
+    const prefix = spawnSync("npm", ["config", "get", "prefix"], { encoding: "utf8", timeout: 5e3 });
+    const root = typeof prefix.stdout === "string" ? prefix.stdout.trim() : "";
+    if (root && root !== "undefined") addBundle(join12(root, "lib", "node_modules"));
+  } catch {
+  }
+  return [...new Set(candidates.filter(Boolean))];
+}
+async function resolveBundleDir(candidate) {
+  try {
+    if (candidate.endsWith(`${join12("@google", "gemini-cli", "bundle")}`)) {
+      return candidate;
+    }
+    const real = await realpath(candidate);
+    return dirname(real);
+  } catch {
+    return null;
+  }
+}
+async function scanBundleDir(dir) {
+  let entries;
+  try {
+    entries = await readdir6(dir);
+  } catch {
+    return null;
+  }
+  const targets = entries.filter((name) => name === "gemini.js" || name.startsWith("chunk-") && name.endsWith(".js"));
+  for (const name of targets) {
+    const filePath = join12(dir, name);
+    try {
+      const info = await stat(filePath);
+      if (!info.isFile() || info.size > MAX_BUNDLE_READ) continue;
+      const contents = await readFile6(filePath, "utf8");
+      if (!contents.includes("OAUTH_CLIENT_SECRET")) continue;
+      const match = GOOGLE_OAUTH_CLIENT_REGEX.exec(contents);
+      if (match) return { clientId: match[1], clientSecret: match[2] };
+    } catch {
+    }
+  }
+  return null;
+}
+async function discoverGoogleOAuthClient() {
+  try {
+    for (const candidate of geminiBundleCandidates()) {
+      const dir = await resolveBundleDir(candidate);
+      if (!dir) continue;
+      const found = await scanBundleDir(dir);
+      if (found) return found;
+    }
+  } catch {
+  }
+  return null;
+}
+async function resolveGoogleClient() {
+  const envId = process.env.TOKMON_GOOGLE_CLIENT_ID?.trim();
+  const envSecret = process.env.TOKMON_GOOGLE_CLIENT_SECRET?.trim();
+  if (envId && envSecret) return { clientId: envId, clientSecret: envSecret };
+  if (cachedClient === void 0) cachedClient = await discoverGoogleOAuthClient();
+  return cachedClient;
+}
+async function refreshAccessToken(refreshToken) {
+  if (!refreshToken) return null;
+  const client = await resolveGoogleClient();
+  if (!client) return null;
+  const body = new URLSearchParams({
+    client_id: client.clientId,
+    client_secret: client.clientSecret,
+    refresh_token: refreshToken,
+    grant_type: "refresh_token"
+  });
+  try {
+    const res = await fetch(GOOGLE_OAUTH_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body,
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!res.ok) return null;
+    const json = await readJson(res);
+    return typeof json?.access_token === "string" && json.access_token.trim() ? json.access_token.trim() : null;
+  } catch {
+    return null;
+  }
+}
+async function requestCloudCodeJson(path, token, body) {
+  for (const base of CLOUD_CODE_URLS) {
+    try {
+      const res = await fetch(`${base}${path}`, {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+          "User-Agent": "agy"
+        },
+        body: JSON.stringify(body ?? {}),
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (res.status === 401 || res.status === 403) return { _authFailed: true };
+      if (!res.ok) continue;
+      const json = await readJson(res);
+      if (json && typeof json === "object") return json;
+    } catch {
+    }
+  }
+  return null;
+}
+function readPlan(loadData) {
+  const paid = typeof loadData?.paidTier?.name === "string" ? loadData.paidTier.name.trim() : "";
+  const current = typeof loadData?.currentTier?.name === "string" ? loadData.currentTier.name.trim() : "";
+  const raw = paid || current;
+  if (!raw) return null;
+  return raw.replace(/^Gemini Code Assist (?:in|for)\s+/i, "").replace(/^Gemini Code Assist$/i, "Code Assist");
+}
+function parseBuckets(data) {
+  if (!Array.isArray(data?.buckets)) return [];
+  return data.buckets.flatMap((bucket) => {
+    const modelId = typeof bucket?.modelId === "string" ? bucket.modelId.trim() : "";
+    if (!modelId) return [];
+    return [{
+      modelId,
+      remainingFraction: typeof bucket.remainingFraction === "number" ? bucket.remainingFraction : 0,
+      resetTime: typeof bucket.resetTime === "string" ? bucket.resetTime : void 0
+    }];
+  });
+}
+function parseModelBuckets(data) {
+  const models = data?.models;
+  if (!models || typeof models !== "object") return [];
+  return Object.keys(models).flatMap((key) => {
+    const model = models[key];
+    if (!model || typeof model !== "object" || model.isInternal) return [];
+    const modelId = typeof model.model === "string" && model.model.trim() ? model.model.trim() : key;
+    if (CC_MODEL_BLACKLIST[modelId]) return [];
+    const displayName = typeof model.displayName === "string" && model.displayName.trim() || typeof model.label === "string" && model.label.trim() || "";
+    if (!displayName) return [];
+    const quotaInfo = model.quotaInfo;
+    return [{
+      modelId: displayName,
+      remainingFraction: typeof quotaInfo?.remainingFraction === "number" ? quotaInfo.remainingFraction : 0,
+      resetTime: typeof quotaInfo?.resetTime === "string" ? quotaInfo.resetTime : void 0
+    }];
+  });
+}
+async function fetchWithAccessToken(accessToken) {
+  const loadData = await requestCloudCodeJson(LOAD_CODE_ASSIST_PATH, accessToken, {});
+  if (!loadData) return { ok: false, plan: null, error: "Cloud Code API error" };
+  if ("_authFailed" in loadData) return { ok: false, plan: null, error: "Token expired" };
+  const plan = readPlan(loadData);
+  const project = typeof loadData.cloudaicompanionProject === "string" && loadData.cloudaicompanionProject.trim() ? loadData.cloudaicompanionProject.trim() : null;
+  let quotaData = project ? await requestCloudCodeJson(RETRIEVE_QUOTA_PATH, accessToken, { project }) : null;
+  if (!quotaData || "_authFailed" in quotaData) {
+    quotaData = await requestCloudCodeJson(RETRIEVE_QUOTA_PATH, accessToken, {});
+  }
+  if (!quotaData) return { ok: false, plan, error: "Cloud Code quota unavailable" };
+  if ("_authFailed" in quotaData) return { ok: false, plan, error: "Token expired" };
+  let buckets = parseBuckets(quotaData);
+  if (buckets.length === 0) {
+    const modelData = await requestCloudCodeJson(FETCH_MODELS_PATH, accessToken, {});
+    if (modelData && !("_authFailed" in modelData)) buckets = parseModelBuckets(modelData);
+    if (modelData && "_authFailed" in modelData) return { ok: false, plan, error: "Token expired" };
+  }
+  if (buckets.length === 0) return { ok: false, plan, error: "No quota data" };
+  return { ok: true, plan, buckets };
+}
+async function fetchCloudCodeQuota(token, expiredMessage = "Token expired") {
+  const nowSec = Math.floor(Date.now() / 1e3);
+  let accessToken = token.accessToken?.trim() || null;
+  if (accessToken && token.expirySeconds && token.expirySeconds <= nowSec) {
+    accessToken = await refreshAccessToken(token.refreshToken);
+    if (!accessToken) return { ok: false, plan: null, error: expiredMessage };
+  }
+  if (!accessToken) {
+    accessToken = await refreshAccessToken(token.refreshToken);
+    if (!accessToken) return { ok: false, plan: null, error: `Missing credentials (${redact(token.accessToken)})` };
+  }
+  const result = await fetchWithAccessToken(accessToken);
+  if (result.ok || result.error !== "Token expired") return result;
+  const refreshed = await refreshAccessToken(token.refreshToken);
+  if (!refreshed) return { ok: false, plan: result.plan, error: expiredMessage };
+  return fetchWithAccessToken(refreshed);
+}
+function normalizeLabel(label) {
+  return label.replace(/\s*\([^)]*\)\s*$/, "").trim();
+}
+function poolLabel(label) {
+  const lower = normalizeLabel(label).toLowerCase();
+  if (lower.includes("gemini") && lower.includes("pro")) return "Pro";
+  if (lower.includes("gemini") && lower.includes("flash")) return "Flash";
+  return "Claude";
+}
+function sortKey(label) {
+  const lower = label.toLowerCase();
+  if (lower.includes("gemini") && lower.includes("pro")) return `0a_${label}`;
+  if (lower.includes("gemini")) return `0b_${label}`;
+  if (lower.includes("claude") && lower.includes("opus")) return `1a_${label}`;
+  if (lower.includes("claude")) return `1b_${label}`;
+  return `2_${label}`;
+}
+function cloudCodeBucketsToMetrics(buckets) {
+  const pooled = /* @__PURE__ */ new Map();
+  for (const bucket of buckets) {
+    const label = poolLabel(bucket.modelId);
+    const existing = pooled.get(label);
+    if (!existing || bucket.remainingFraction < existing.remainingFraction) {
+      pooled.set(label, { ...bucket, modelId: label });
+    }
+  }
+  return [...pooled.values()].sort((a, b) => sortKey(a.modelId).localeCompare(sortKey(b.modelId))).map((bucket, i) => {
+    const clamped = Math.max(0, Math.min(1, bucket.remainingFraction));
+    return {
+      label: bucket.modelId,
+      used: Math.round((1 - clamped) * 100),
+      limit: 100,
+      format: { kind: "percent" },
+      resetsAt: bucket.resetTime ? resetIn(bucket.resetTime) : null,
+      primary: i === 0
+    };
+  });
+}
+function cloudCodeSqliteError(status) {
+  return status === "ok" ? "Not signed in \u2014 open Antigravity" : sqliteStatusMessage(status).replace(/Cursor/g, "Antigravity");
+}
+
+// src/providers/antigravity/billing.ts
+async function exists(path) {
+  try {
+    await access7(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function firstExisting(paths) {
+  for (const path of paths) {
+    if (await exists(path)) return path;
+  }
+  return paths[0];
+}
+async function antigravityStateDb(homeDir) {
+  const base = homeDir ?? homedir11();
+  const tail = ["User", "globalStorage", "state.vscdb"];
+  if (process.platform === "darwin") {
+    const support = join13(base, "Library", "Application Support");
+    const exact = [
+      join13(support, "Antigravity IDE", ...tail),
+      join13(support, "Antigravity", ...tail)
+    ];
+    try {
+      const entries = await readdir7(support, { withFileTypes: true });
+      const matches = entries.filter((e) => e.isDirectory() && e.name.includes("Antigravity")).map((e) => join13(support, e.name, ...tail));
+      return firstExisting([...exact, ...matches]);
+    } catch {
+      return firstExisting(exact);
+    }
+  }
+  if (process.platform === "win32") {
+    const roaming = homeDir ? join13(homeDir, "AppData", "Roaming") : envDir("APPDATA") ?? join13(base, "AppData", "Roaming");
+    return firstExisting([
+      join13(roaming, "Antigravity IDE", ...tail),
+      join13(roaming, "Antigravity", ...tail)
+    ]);
+  }
+  const cfg = homeDir ? join13(homeDir, ".config") : envDir("XDG_CONFIG_HOME") ?? join13(base, ".config");
+  return firstExisting([
+    join13(cfg, "Antigravity IDE", ...tail),
+    join13(cfg, "Antigravity", ...tail)
+  ]);
+}
+async function detectAntigravity(homeDir) {
+  return exists(await antigravityStateDb(homeDir));
+}
+async function antigravityBilling(account) {
+  try {
+    const db = await antigravityStateDb(account.homeDir);
+    const { token, status } = await readAntigravityOAuthToken(db);
+    if (!token) return { plan: null, metrics: [], error: cloudCodeSqliteError(status) };
+    const quota = await fetchCloudCodeQuota(token, "Token expired \u2014 open Antigravity");
+    if (!quota.ok) return { plan: quota.plan, metrics: [], error: quota.error };
+    return { plan: quota.plan, metrics: cloudCodeBucketsToMetrics(quota.buckets), error: null };
+  } catch {
+    return { plan: null, metrics: [], error: "Antigravity billing unavailable" };
+  }
+}
+
+// src/providers/antigravity/index.ts
+var antigravityProvider = {
+  id: "antigravity",
+  name: "Antigravity",
+  color: "red",
+  hasUsage: false,
+  hasBilling: true,
+  detect: (homeDir) => detectAntigravity(homeDir),
+  fetchBilling: (account) => antigravityBilling(account)
+};
+
+// src/providers/gemini/billing.ts
+import { access as access8, readFile as readFile7 } from "fs/promises";
+import { join as join14 } from "path";
+import { homedir as homedir12 } from "os";
+function geminiCredsPath(homeDir) {
+  return join14(homeDir ?? homedir12(), ".gemini", "oauth_creds.json");
+}
+async function detectGemini(homeDir) {
+  try {
+    await access8(geminiCredsPath(homeDir));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readGeminiCreds(path) {
+  try {
+    return JSON.parse(await readFile7(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function geminiBilling(account) {
+  try {
+    const creds = await readGeminiCreds(geminiCredsPath(account.homeDir));
+    const accessToken = typeof creds?.access_token === "string" ? creds.access_token.trim() : "";
+    const refreshToken = typeof creds?.refresh_token === "string" ? creds.refresh_token.trim() : null;
+    if (!creds || !accessToken && !refreshToken) return { plan: null, metrics: [], error: "Not signed in \u2014 run gemini" };
+    const quota = await fetchCloudCodeQuota({
+      accessToken,
+      refreshToken,
+      expirySeconds: typeof creds.expiry_date === "number" ? Math.floor(creds.expiry_date / 1e3) : null
+    }, "Token expired \u2014 run gemini");
+    if (!quota.ok) return { plan: quota.plan, metrics: [], error: quota.error };
+    return { plan: quota.plan, metrics: cloudCodeBucketsToMetrics(quota.buckets), error: null };
+  } catch {
+    return { plan: null, metrics: [], error: "Gemini billing unavailable" };
+  }
+}
+
+// src/providers/gemini/index.ts
+var geminiProvider = {
+  id: "gemini",
+  name: "Gemini",
+  color: "greenBright",
+  hasUsage: false,
+  hasBilling: true,
+  detect: (homeDir) => detectGemini(homeDir),
+  fetchBilling: (account) => geminiBilling(account)
+};
+
+// src/providers/detect.ts
+import { accessSync, constants } from "fs";
+import { join as join15, delimiter, isAbsolute as isAbsolute3 } from "path";
+import { homedir as homedir13 } from "os";
+function searchDirs() {
+  const home = homedir13();
+  const fromEnv = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+  const extra = process.platform === "win32" ? [
+    process.env.APPDATA && join15(process.env.APPDATA, "npm"),
+    process.env.LOCALAPPDATA && join15(process.env.LOCALAPPDATA, "pnpm"),
+    join15(home, "scoop", "shims")
+  ] : [
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+    "/opt/local/bin",
+    join15(home, ".local", "bin"),
+    join15(home, "bin"),
+    join15(home, ".npm-global", "bin"),
+    join15(home, ".bun", "bin"),
+    join15(home, ".local", "share", "pnpm")
+  ];
+  return [.../* @__PURE__ */ new Set([...fromEnv, ...extra.filter((d) => !!d)])];
+}
+function isExec(p) {
+  try {
+    accessSync(p, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function onPath(names) {
+  const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").map((e) => e.toLowerCase()).concat("") : [""];
+  for (const dir of searchDirs()) {
+    for (const n of names) {
+      for (const e of exts) {
+        if (isExec(join15(dir, n + e))) return true;
+      }
+    }
+  }
+  return false;
+}
+function anyExists(paths) {
+  return paths.some((p) => !!p && isExec(p));
+}
+function installSignals(id) {
+  const home = homedir13();
+  const pf = process.env.ProgramFiles;
+  const pf86 = process.env["ProgramFiles(x86)"];
+  const lad = process.env.LOCALAPPDATA;
+  switch (id) {
+    case "claude":
+      return onPath(["claude"]) || anyExists([
+        "/Applications/Claude.app",
+        join15(home, "Applications", "Claude.app"),
+        lad && join15(lad, "Programs", "claude", "Claude.exe")
+      ]);
+    case "codex": {
+      const bin = process.env.CODEX_BIN;
+      if (bin && isAbsolute3(bin) && isExec(bin)) return true;
+      return onPath(["codex"]);
+    }
+    case "cursor":
+      return onPath(["cursor", "cursor-agent"]) || anyExists([
+        "/Applications/Cursor.app",
+        join15(home, "Applications", "Cursor.app"),
+        lad && join15(lad, "Programs", "cursor", "Cursor.exe"),
+        pf && join15(pf, "Cursor", "Cursor.exe"),
+        pf86 && join15(pf86, "Cursor", "Cursor.exe"),
+        "/opt/Cursor/cursor",
+        "/usr/share/cursor/cursor",
+        "/usr/bin/cursor"
+      ]);
+    case "pi":
+      return onPath(["pi"]);
+    case "opencode":
+      return onPath(["opencode"]);
+    case "copilot":
+      return onPath(["gh"]);
+    case "antigravity":
+      return onPath(["antigravity"]) || anyExists([
+        "/Applications/Antigravity.app",
+        join15(home, "Applications", "Antigravity.app"),
+        lad && join15(lad, "Programs", "Antigravity", "Antigravity.exe")
+      ]);
+    case "gemini":
+      return onPath(["gemini"]);
+    default:
+      return false;
+  }
+}
+
+// src/providers/index.ts
+var PROVIDER_ORDER = ["claude", "codex", "cursor", "copilot", "pi", "opencode", "antigravity", "gemini"];
+var PROVIDERS = {
+  claude: claudeProvider,
+  codex: codexProvider,
+  cursor: cursorProvider,
+  pi: piProvider,
+  opencode: opencodeProvider,
+  copilot: copilotProvider,
+  antigravity: antigravityProvider,
+  gemini: geminiProvider
+};
+var ALL_PROVIDERS = PROVIDER_ORDER.map((id) => PROVIDERS[id]);
+async function detectProviders() {
+  const found = await Promise.all(
+    PROVIDER_ORDER.map(async (id) => {
+      try {
+        if (installSignals(id)) return id;
+        return await PROVIDERS[id].detect() ? id : null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  return found.filter((id) => id !== null);
+}
+
+// src/accounts.ts
+function buildAccounts(config, detected) {
+  const out = [];
+  for (const pid of PROVIDER_ORDER) {
+    if (config.disabledProviders.includes(pid)) continue;
+    const provider = PROVIDERS[pid];
+    const configured = config.accounts.filter((a) => a.providerId === pid);
+    if (configured.length > 0) {
+      for (const a of configured) {
+        out.push({
+          id: a.id,
+          providerId: pid,
+          name: a.name,
+          color: a.color || provider.color,
+          homeDir: a.homeDir && a.homeDir !== "~" ? expandHome(a.homeDir) : void 0
+        });
+      }
+    } else if (detected.includes(pid)) {
+      out.push({ id: pid, providerId: pid, name: provider.name, color: provider.color, homeDir: void 0 });
+    }
+  }
+  return out;
+}
+function accountsByProvider(accounts) {
+  const groups = [];
+  for (const pid of PROVIDER_ORDER) {
+    const list = accounts.filter((a) => a.providerId === pid);
+    if (list.length > 0) groups.push({ provider: pid, accounts: list });
+  }
+  return groups;
+}
+
+export {
+  configLocation,
+  cacheDir,
+  loadConfig,
+  saveConfig,
+  generateAccountId,
+  pickAccentColor,
+  systemTimezone,
+  isValidTimezone,
+  resolveTimezone,
+  flushDisk,
+  mergeTables,
+  readJson,
+  currency,
+  tokens,
+  time,
+  shortDate,
+  col,
+  cursorModelSpend,
+  PROVIDER_ORDER,
+  PROVIDERS,
+  detectProviders,
+  buildAccounts,
+  accountsByProvider
+};