just-usage 0.0.1

package/dist/cli.js

@@ -0,0 +1,2029 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli.ts
+import { parseArgs } from "node:util";
+import { createInterface as createInterface2 } from "node:readline";
+
+// src/adapters/codex.ts
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+
+// src/config.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync } from "node:fs";
+// package.json
+var package_default = {
+  name: "just-usage",
+  version: "0.0.1",
+  description: "One local page for your coding-CLI subscription quotas: Claude, Codex, Cursor, OpenCode Go.",
+  type: "module",
+  license: "MIT",
+  author: "spheceo",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/spheceo/just-usage.git"
+  },
+  homepage: "https://github.com/spheceo/just-usage#readme",
+  bugs: "https://github.com/spheceo/just-usage/issues",
+  keywords: [
+    "claude",
+    "codex",
+    "cursor",
+    "opencode",
+    "quota",
+    "usage",
+    "rate-limit",
+    "cli"
+  ],
+  bin: {
+    "just-usage": "dist/cli.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  scripts: {
+    dev: "bun run src/cli.ts",
+    build: "bun run scripts/build.ts",
+    test: "bun test",
+    typecheck: "tsc --noEmit",
+    release: "bun run scripts/release.ts",
+    prepublishOnly: "bun run build"
+  },
+  devDependencies: {
+    "@types/bun": "^1.2.0",
+    "@types/node": "^22.0.0",
+    typescript: "^5.6.0"
+  }
+};
+
+// src/config.ts
+var VERSION = package_default.version;
+var PACKAGE_NAME = "just-usage";
+var GITHUB_REPO = "spheceo/just-usage";
+var DEFAULT_PORT = 5757;
+var DEFAULT_HOST = "0.0.0.0";
+var CACHE_TTL_MS = 120000;
+var FETCH_TIMEOUT_MS = 20000;
+function configDir() {
+  const override = process.env.JUST_USAGE_HOME;
+  if (override)
+    return override;
+  const xdg = process.env.XDG_CONFIG_HOME;
+  return join(xdg && xdg.trim() ? xdg : join(homedir(), ".config"), PACKAGE_NAME);
+}
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  return dir;
+}
+var paths = {
+  registry: () => join(configDir(), "accounts.json"),
+  secrets: () => join(configDir(), "secrets.json"),
+  updateCache: () => join(configDir(), "update-check.json"),
+  profiles: (provider) => join(configDir(), "profiles", provider)
+};
+
+// src/format.ts
+function parseSemver(v) {
+  const m = v.trim().replace(/^v/, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/);
+  if (!m)
+    return null;
+  return { nums: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ?? null };
+}
+function semverGt(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  if (!pa || !pb)
+    return false;
+  for (let i = 0;i < 3; i++) {
+    const x = pa.nums[i] ?? 0;
+    const y = pb.nums[i] ?? 0;
+    if (x !== y)
+      return x > y;
+  }
+  if (pa.pre === pb.pre)
+    return false;
+  if (pa.pre === null)
+    return true;
+  if (pb.pre === null)
+    return false;
+  return pa.pre > pb.pre;
+}
+function epochToIso(v) {
+  if (typeof v === "string" && /^\d+$/.test(v))
+    v = Number(v);
+  if (typeof v !== "number" || !Number.isFinite(v) || v <= 0)
+    return null;
+  const ms = v < 1000000000000 ? v * 1000 : v;
+  return new Date(ms).toISOString();
+}
+function isoOrNull(v) {
+  if (typeof v !== "string" || !v.trim())
+    return null;
+  const t = Date.parse(v);
+  return Number.isFinite(t) ? new Date(t).toISOString() : null;
+}
+function clampPercent(v) {
+  if (typeof v === "string" && v.trim() !== "")
+    v = Number(v);
+  if (typeof v !== "number" || !Number.isFinite(v))
+    return null;
+  return Math.min(100, Math.max(0, Math.round(v * 10) / 10));
+}
+function windowLabel(minutes) {
+  if (minutes === null)
+    return "Window";
+  if (minutes === 300)
+    return "5h";
+  if (minutes === 10080)
+    return "Weekly";
+  if (minutes % 1440 === 0)
+    return `${minutes / 1440}d`;
+  if (minutes % 60 === 0)
+    return `${minutes / 60}h`;
+  return `${minutes}m`;
+}
+function formatDuration(ms) {
+  if (ms <= 0)
+    return "now";
+  const totalMin = Math.round(ms / 60000);
+  const d = Math.floor(totalMin / 1440);
+  const h = Math.floor(totalMin % 1440 / 60);
+  const m = totalMin % 60;
+  if (d > 0)
+    return h > 0 ? `${d}d ${h}h` : `${d}d`;
+  if (h > 0)
+    return m > 0 ? `${h}h ${m}m` : `${h}h`;
+  return `${Math.max(1, m)}m`;
+}
+function formatResetIn(resetsAt, now = Date.now(), kind = "rolling") {
+  if (!resetsAt)
+    return null;
+  const t = Date.parse(resetsAt);
+  if (!Number.isFinite(t))
+    return null;
+  const diff = t - now;
+  if (kind === "cycle")
+    return diff <= 0 ? "renewing" : `renews in ${formatDuration(diff)}`;
+  return diff <= 0 ? "resetting" : `resets in ${formatDuration(diff)}`;
+}
+function severity(usedPercent) {
+  if (usedPercent === null)
+    return null;
+  if (usedPercent >= 85)
+    return "crit";
+  if (usedPercent >= 60)
+    return "warn";
+  return "ok";
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/@.*$/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "account";
+}
+
+// src/adapters/common.ts
+function snapshot(account, status, patch = {}) {
+  const { email, plan, ...rest } = patch;
+  return {
+    account: {
+      id: account.id,
+      provider: account.provider,
+      label: account.label,
+      email: email ?? account.email ?? null,
+      plan: plan ?? null,
+      kind: account.kind
+    },
+    status,
+    message: null,
+    windows: [],
+    resetCredits: null,
+    fetchedAt: new Date().toISOString(),
+    ...rest
+  };
+}
+function errorMessage(e) {
+  if (e instanceof Error)
+    return e.message;
+  return String(e);
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+async function fetchJson(url, init = {}) {
+  const { timeoutMs = 15000, ...rest } = init;
+  const res = await fetch(url, { ...rest, signal: AbortSignal.timeout(timeoutMs) });
+  const text = await res.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {
+    body = null;
+  }
+  return { status: res.status, body, text };
+}
+
+// src/adapters/codex.ts
+class AppServerClient {
+  proc;
+  nextId = 1;
+  pending = new Map;
+  listeners = new Set;
+  exited = false;
+  constructor(proc) {
+    this.proc = proc;
+    createInterface({ input: proc.stdout }).on("line", (line) => this.onLine(line));
+    proc.stderr.on("data", () => {});
+    proc.on("exit", () => {
+      this.exited = true;
+      for (const p of this.pending.values()) {
+        clearTimeout(p.timer);
+        p.reject(new Error("codex app-server exited"));
+      }
+      this.pending.clear();
+    });
+  }
+  static async start(codexHome) {
+    const env = { ...process.env };
+    if (codexHome)
+      env.CODEX_HOME = codexHome;
+    const proc = spawn("codex", ["app-server"], { env, stdio: ["pipe", "pipe", "pipe"] });
+    await new Promise((resolve, reject) => {
+      proc.once("spawn", () => resolve());
+      proc.once("error", (e) => reject(new Error(`could not start codex app-server: ${e.message}`)));
+    });
+    const client = new AppServerClient(proc);
+    await client.request("initialize", {
+      clientInfo: { name: "just-usage", title: "just-usage", version: VERSION },
+      capabilities: {}
+    });
+    client.notify("initialized", {});
+    return client;
+  }
+  onLine(line) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (typeof msg.id === "number" && (("result" in msg) || ("error" in msg))) {
+      const p = this.pending.get(msg.id);
+      if (!p)
+        return;
+      this.pending.delete(msg.id);
+      clearTimeout(p.timer);
+      if (msg.error) {
+        const err = msg.error;
+        p.reject(new Error(String(err.message ?? "app-server error")));
+      } else {
+        p.resolve(msg.result);
+      }
+      return;
+    }
+    if (typeof msg.method === "string" && !("id" in msg)) {
+      for (const l of this.listeners)
+        l({ method: msg.method, params: msg.params });
+    }
+  }
+  request(method, params, timeoutMs = 20000) {
+    if (this.exited)
+      return Promise.reject(new Error("codex app-server exited"));
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + `
+`);
+    });
+  }
+  notify(method, params) {
+    this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + `
+`);
+  }
+  onNotification(cb) {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+  close() {
+    if (!this.exited)
+      this.proc.kill();
+  }
+}
+function windowsFromLimit(limit, prefix, labelPrefix) {
+  const out = [];
+  for (const key of ["primary", "secondary"]) {
+    const w = limit[key];
+    if (!isObject(w))
+      continue;
+    const minutes = typeof w.windowDurationMins === "number" ? w.windowDurationMins : null;
+    out.push({
+      id: `${prefix}${key}`,
+      label: `${labelPrefix}${windowLabel(minutes)}`,
+      usedPercent: clampPercent(w.usedPercent),
+      resetsAt: epochToIso(w.resetsAt),
+      windowMinutes: minutes,
+      kind: "rolling"
+    });
+  }
+  return out;
+}
+function normalizeCodexRateLimits(result) {
+  const empty = { windows: [], plan: null, resetCredits: null };
+  if (!isObject(result))
+    return empty;
+  const byId = isObject(result.rateLimitsByLimitId) ? result.rateLimitsByLimitId : null;
+  const limits = byId ? Object.values(byId).filter(isObject) : isObject(result.rateLimits) ? [result.rateLimits] : [];
+  const windows = [];
+  let plan = null;
+  const multi = limits.length > 1;
+  for (const limit of limits) {
+    const limitId = typeof limit.limitId === "string" ? limit.limitId : "codex";
+    const limitName = typeof limit.limitName === "string" && limit.limitName ? limit.limitName : null;
+    const labelPrefix = multi && limitName ? `${limitName} · ` : multi && limitId !== "codex" ? `${limitId} · ` : "";
+    windows.push(...windowsFromLimit(limit, `${limitId}:`, labelPrefix));
+    if (!plan && typeof limit.planType === "string")
+      plan = limit.planType;
+  }
+  windows.sort((a, b) => Number(!a.id.startsWith("codex:")) - Number(!b.id.startsWith("codex:")));
+  let resetCredits = null;
+  const rc = result.rateLimitResetCredits;
+  if (isObject(rc)) {
+    const credits = Array.isArray(rc.credits) ? rc.credits.filter(isObject).map((c) => ({
+      id: String(c.id ?? ""),
+      title: typeof c.title === "string" ? c.title : null,
+      status: typeof c.status === "string" ? c.status : null,
+      expiresAt: epochToIso(c.expiresAt)
+    })) : [];
+    const availableCount = typeof rc.availableCount === "number" ? rc.availableCount : credits.filter((c) => c.status === "available").length;
+    resetCredits = { availableCount, credits };
+  }
+  return { windows, plan, resetCredits };
+}
+async function fetchCodex(account) {
+  let client = null;
+  try {
+    client = await AppServerClient.start(account.path);
+    const acct = await client.request("account/read", { refreshToken: false });
+    const info = isObject(acct.account) ? acct.account : null;
+    if (!info) {
+      return snapshot(account, "signed_out", {
+        message: account.kind === "default" ? "Not signed in. Run `codex login`." : `Not signed in. Run \`just-usage login ${account.id}\`.`
+      });
+    }
+    const email = typeof info.email === "string" ? info.email : null;
+    const planFromAccount = typeof info.planType === "string" ? info.planType : null;
+    if (info.type === "apiKey") {
+      return snapshot(account, "unsupported", { email, plan: "api key", message: "API-key logins have no subscription windows." });
+    }
+    const raw = await client.request("account/rateLimits/read", {});
+    const norm = normalizeCodexRateLimits(raw);
+    return snapshot(account, "ok", {
+      email,
+      plan: norm.plan ?? planFromAccount,
+      windows: norm.windows,
+      resetCredits: norm.resetCredits
+    });
+  } catch (e) {
+    return snapshot(account, "error", { message: errorMessage(e) });
+  } finally {
+    client?.close();
+  }
+}
+async function codexLogin(codexHome, onAuthUrl, timeoutMs = 5 * 60000) {
+  const client = await AppServerClient.start(codexHome);
+  try {
+    const completed = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("login timed out")), timeoutMs);
+      client.onNotification((n) => {
+        if (n.method !== "account/login/completed")
+          return;
+        clearTimeout(timer);
+        const p = isObject(n.params) ? n.params : {};
+        if (p.success)
+          resolve();
+        else
+          reject(new Error(typeof p.error === "string" ? p.error : "login failed"));
+      });
+    });
+    const start = await client.request("account/login/start", { type: "chatgpt" });
+    if (typeof start.authUrl === "string")
+      onAuthUrl(start.authUrl);
+    await completed;
+    const acct = await client.request("account/read", {});
+    const info = isObject(acct.account) ? acct.account : {};
+    return {
+      email: typeof info.email === "string" ? info.email : null,
+      plan: typeof info.planType === "string" ? info.planType : null
+    };
+  } finally {
+    client.close();
+  }
+}
+
+// src/adapters/claude.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/proc.ts
+import { spawn as spawn2 } from "node:child_process";
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ code, stdout, stderr });
+    };
+    const child = spawn2(cmd, args, {
+      env: { ...process.env, ...opts.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      stderr += `
+[just-usage] timed out`;
+      finish(null);
+    }, opts.timeoutMs ?? 15000);
+    child.stdout.on("data", (d) => stdout += d);
+    child.stderr.on("data", (d) => stderr += d);
+    child.on("error", (err) => {
+      stderr += String(err);
+      finish(null);
+    });
+    child.on("close", (code) => finish(code));
+    if (opts.input !== undefined)
+      child.stdin.write(opts.input);
+    child.stdin.end();
+  });
+}
+function runInteractive(cmd, args, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(cmd, args, { env: { ...process.env, ...env }, stdio: "inherit" });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code));
+  });
+}
+var whichCache = new Map;
+function which(bin) {
+  let p = whichCache.get(bin);
+  if (!p) {
+    p = (async () => {
+      const finder = process.platform === "win32" ? "where" : "which";
+      const res = await run(finder, [bin], { timeoutMs: 5000 });
+      if (res.code !== 0)
+        return null;
+      const first = res.stdout.split(/\r?\n/).map((s) => s.trim()).find(Boolean);
+      return first ?? null;
+    })();
+    whichCache.set(bin, p);
+  }
+  return p;
+}
+var versionCache = new Map;
+function binVersion(bin) {
+  let p = versionCache.get(bin);
+  if (!p) {
+    p = (async () => {
+      const res = await run(bin, ["--version"], { timeoutMs: 8000 });
+      const text = `${res.stdout}
+${res.stderr}`;
+      const m = text.match(/\d+\.\d+\.\d+(?:[-.][0-9A-Za-z.-]+)?/);
+      return m ? m[0] : null;
+    })();
+    versionCache.set(bin, p);
+  }
+  return p;
+}
+function openInBrowser(url) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    const child = spawn2(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {});
+    child.unref();
+  } catch {}
+}
+function stripAnsi(s) {
+  return s.replace(/\u001b\[[0-9;]*[A-Za-z]/g, "");
+}
+function withTimeout(p, ms, label) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error(`${label} timed out after ${Math.round(ms / 1000)}s`)), ms);
+    p.then((v) => {
+      clearTimeout(t);
+      resolve(v);
+    }, (e) => {
+      clearTimeout(t);
+      reject(e);
+    });
+  });
+}
+
+// src/secrets.ts
+import { existsSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { dirname } from "node:path";
+var SERVICE = "just-usage";
+
+class KeychainStore {
+  kind = "keychain";
+  async get(id) {
+    const res = await run("security", ["find-generic-password", "-a", id, "-s", SERVICE, "-w"], { timeoutMs: 1e4 });
+    if (res.code !== 0)
+      return null;
+    const v = res.stdout.replace(/\r?\n$/, "");
+    return v || null;
+  }
+  async set(id, value) {
+    const res = await run("security", ["add-generic-password", "-U", "-a", id, "-s", SERVICE, "-w", value], { timeoutMs: 1e4 });
+    if (res.code !== 0)
+      throw new Error(`keychain write failed: ${res.stderr.trim() || res.code}`);
+  }
+  async delete(id) {
+    await run("security", ["delete-generic-password", "-a", id, "-s", SERVICE], { timeoutMs: 1e4 });
+  }
+}
+
+class FileStore {
+  kind = "file";
+  read() {
+    const file = paths.secrets();
+    if (!existsSync(file))
+      return {};
+    try {
+      return JSON.parse(readFileSync(file, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  write(data) {
+    const file = paths.secrets();
+    ensureDir(dirname(file));
+    writeFileSync(file, JSON.stringify(data, null, 2) + `
+`, { mode: 384 });
+    chmodSync(file, 384);
+  }
+  async get(id) {
+    return this.read()[id] ?? null;
+  }
+  async set(id, value) {
+    const data = this.read();
+    data[id] = value;
+    this.write(data);
+  }
+  async delete(id) {
+    const data = this.read();
+    delete data[id];
+    this.write(data);
+  }
+}
+var store = null;
+function secretStore() {
+  if (!store) {
+    const forced = process.env.JUST_USAGE_SECRET_STORE;
+    store = process.platform === "darwin" && forced !== "file" ? new KeychainStore : new FileStore;
+  }
+  return store;
+}
+
+// src/adapters/claude.ts
+var USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+var PROFILE_URL = "https://api.anthropic.com/api/oauth/profile";
+var FALLBACK_CLI_VERSION = "2.1.259";
+function keychainService(configDir2) {
+  if (!configDir2)
+    return "Claude Code-credentials";
+  const hash = createHash("sha256").update(configDir2).digest("hex").slice(0, 8);
+  return `Claude Code-credentials-${hash}`;
+}
+function parseCreds(text) {
+  try {
+    const parsed = JSON.parse(text);
+    const o = isObject(parsed.claudeAiOauth) ? parsed.claudeAiOauth : null;
+    if (!o || typeof o.accessToken !== "string" || !o.accessToken)
+      return null;
+    return {
+      accessToken: o.accessToken,
+      expiresAt: typeof o.expiresAt === "number" ? o.expiresAt : null,
+      subscriptionType: typeof o.subscriptionType === "string" ? o.subscriptionType : null
+    };
+  } catch {
+    return null;
+  }
+}
+async function readClaudeCredentials(configDir2) {
+  if (process.platform === "darwin") {
+    const res = await run("security", ["find-generic-password", "-s", keychainService(configDir2), "-w"], { timeoutMs: 20000 });
+    if (res.code === 0) {
+      const creds = parseCreds(res.stdout.trim());
+      if (creds)
+        return creds;
+    }
+  }
+  const file = join2(configDir2 ?? join2(homedir2(), ".claude"), ".credentials.json");
+  if (existsSync2(file))
+    return parseCreds(readFileSync2(file, "utf8"));
+  return null;
+}
+async function claudeAuthStatus(configDir2) {
+  const env = {};
+  if (configDir2)
+    env.CLAUDE_CONFIG_DIR = configDir2;
+  const res = await run("claude", ["auth", "status", "--json"], { env, timeoutMs: 15000 });
+  if (res.code === null)
+    return null;
+  const m = res.stdout.match(/\{[\s\S]*\}/);
+  if (!m)
+    return null;
+  try {
+    const parsed = JSON.parse(m[0]);
+    return { loggedIn: parsed.loggedIn === true };
+  } catch {
+    return null;
+  }
+}
+async function userAgent() {
+  const v = await binVersion("claude") ?? FALLBACK_CLI_VERSION;
+  return `claude-code/${v}`;
+}
+function headers(token, ua) {
+  return {
+    Authorization: `Bearer ${token}`,
+    "anthropic-beta": "oauth-2025-04-20",
+    "User-Agent": ua,
+    Accept: "application/json, text/plain, */*",
+    "Content-Type": "application/json"
+  };
+}
+function bucket(v, id, label, minutes, kind = "rolling") {
+  if (!isObject(v))
+    return null;
+  const used = clampPercent(v.utilization);
+  if (used === null)
+    return null;
+  return { id, label, usedPercent: used, resetsAt: isoOrNull(v.resets_at), windowMinutes: minutes, kind };
+}
+function normalizeClaudeUsage(body) {
+  if (!isObject(body))
+    return [];
+  const out = [];
+  const push = (w) => w && out.push(w);
+  push(bucket(body.five_hour, "five_hour", "5h", 300));
+  push(bucket(body.seven_day, "seven_day", "Weekly", 10080));
+  push(bucket(body.seven_day_opus, "seven_day_opus", "Weekly · Opus", 10080));
+  push(bucket(body.seven_day_sonnet, "seven_day_sonnet", "Weekly · Sonnet", 10080));
+  push(bucket(body.seven_day_oauth_apps, "seven_day_oauth_apps", "Weekly · OAuth apps", 10080));
+  if (out.length === 0 && Array.isArray(body.limits)) {
+    for (const [i, item] of body.limits.entries()) {
+      if (!isObject(item))
+        continue;
+      const name = [item.name, item.type, item.id].find((x) => typeof x === "string" && x.length > 0) ?? `limit ${i + 1}`;
+      push(bucket(item, `limits:${name}`, name.replace(/_/g, " "), null));
+    }
+  }
+  const extra = body.extra_usage;
+  if (isObject(extra) && extra.is_enabled === true) {
+    const used = clampPercent(extra.utilization);
+    if (used !== null) {
+      const limit = typeof extra.monthly_limit === "number" ? extra.monthly_limit : null;
+      const spent = typeof extra.used_credits === "number" ? extra.used_credits : null;
+      out.push({
+        id: "extra_usage",
+        label: "Extra usage",
+        usedPercent: used,
+        resetsAt: null,
+        windowMinutes: null,
+        kind: "cycle",
+        note: limit !== null && spent !== null ? `${spent.toFixed(2)} of ${limit.toFixed(0)} credits` : undefined
+      });
+    }
+  }
+  return out;
+}
+async function resolveToken(account) {
+  if (account.kind === "token") {
+    const token = await secretStore().get(account.id);
+    if (!token)
+      return { fail: snapshot(account, "error", { message: "Stored token missing. Run `just-usage remove` and add it again." }) };
+    return { token, plan: null };
+  }
+  const status = await claudeAuthStatus(account.path);
+  if (status && !status.loggedIn) {
+    const hint = account.kind === "default" ? "Run `claude` and `/login`." : `Run \`just-usage login ${account.id}\`.`;
+    return { fail: snapshot(account, "signed_out", { message: `Not signed in. ${hint}` }) };
+  }
+  const creds = await readClaudeCredentials(account.path);
+  if (!creds) {
+    return { fail: snapshot(account, "error", { message: "Could not read Claude Code's credential (Keychain access denied or file missing)." }) };
+  }
+  if (creds.expiresAt && creds.expiresAt < Date.now()) {
+    const hint = account.kind === "default" ? "Open `claude` once to refresh it." : `Run \`CLAUDE_CONFIG_DIR=${account.path} claude\` once to refresh it.`;
+    return { fail: snapshot(account, "error", { plan: creds.subscriptionType, message: `Access token expired. ${hint}` }) };
+  }
+  return { token: creds.accessToken, plan: creds.subscriptionType };
+}
+async function fetchClaude(account) {
+  try {
+    const resolved = await resolveToken(account);
+    if ("fail" in resolved)
+      return resolved.fail;
+    const ua = await userAgent();
+    const h = headers(resolved.token, ua);
+    const [usage, profile] = await Promise.all([
+      fetchJson(USAGE_URL, { headers: h }),
+      account.email ? Promise.resolve(null) : fetchJson(PROFILE_URL, { headers: h }).catch(() => null)
+    ]);
+    let email = account.email ?? null;
+    if (profile && profile.status === 200 && isObject(profile.body) && isObject(profile.body.account)) {
+      const e = profile.body.account.email;
+      if (typeof e === "string")
+        email = e;
+    }
+    if (usage.status === 401) {
+      return snapshot(account, "error", { email, plan: resolved.plan, message: "Token rejected (401). Sign in again." });
+    }
+    if (usage.status === 429) {
+      return snapshot(account, "error", { email, plan: resolved.plan, message: "Rate limited by Anthropic (429). Try again in a minute." });
+    }
+    if (usage.status !== 200) {
+      return snapshot(account, "error", { email, plan: resolved.plan, message: `Usage endpoint returned HTTP ${usage.status}.` });
+    }
+    const windows = normalizeClaudeUsage(usage.body);
+    if (windows.length === 0) {
+      return snapshot(account, "unsupported", { email, plan: resolved.plan, message: "Usage response had no recognizable windows (schema may have changed)." });
+    }
+    return snapshot(account, "ok", { email, plan: resolved.plan, windows });
+  } catch (e) {
+    return snapshot(account, "error", { message: errorMessage(e) });
+  }
+}
+async function verifyClaudeToken(token) {
+  const h = headers(token, await userAgent());
+  const res = await fetchJson(USAGE_URL, { headers: h });
+  if (res.status === 401)
+    return { ok: false, email: null, message: "Token rejected (401)." };
+  if (res.status !== 200)
+    return { ok: false, email: null, message: `HTTP ${res.status} from usage endpoint.` };
+  let email = null;
+  const profile = await fetchJson(PROFILE_URL, { headers: h }).catch(() => null);
+  if (profile && profile.status === 200 && isObject(profile.body) && isObject(profile.body.account) && typeof profile.body.account.email === "string") {
+    email = profile.body.account.email;
+  }
+  return { ok: true, email, message: "ok" };
+}
+
+// src/adapters/opencode.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+var USAGE_URL2 = "https://opencode.ai/zen/go/v1/usage";
+function openCodeAuthFile() {
+  if (process.env.OPENCODE_AUTH_FILE)
+    return process.env.OPENCODE_AUTH_FILE;
+  const xdg = process.env.XDG_DATA_HOME;
+  const base = xdg && xdg.trim() ? xdg : join3(homedir3(), ".local", "share");
+  return join3(base, "opencode", "auth.json");
+}
+function readOpenCodeGoKey() {
+  const file = openCodeAuthFile();
+  if (!existsSync3(file))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync3(file, "utf8"));
+    const entry = parsed["opencode-go"];
+    if (isObject(entry) && typeof entry.key === "string" && entry.key)
+      return entry.key;
+    return null;
+  } catch {
+    return null;
+  }
+}
+var WINDOWS = [
+  { key: "rolling", id: "rolling", label: "5h", minutes: 300, kind: "rolling" },
+  { key: "weekly", id: "weekly", label: "Weekly", minutes: 10080, kind: "rolling" },
+  { key: "monthly", id: "monthly", label: "Monthly", minutes: null, kind: "cycle" }
+];
+function normalizeOpenCodeUsage(body) {
+  if (!isObject(body))
+    return [];
+  const usage = isObject(body.usage) ? body.usage : body;
+  const out = [];
+  for (const def of WINDOWS) {
+    const w = usage[def.key];
+    if (!isObject(w))
+      continue;
+    let used = clampPercent(w.percent);
+    if (w.status === "rate-limited")
+      used = 100;
+    if (used === null)
+      continue;
+    out.push({ id: def.id, label: def.label, usedPercent: used, resetsAt: isoOrNull(w.resetsAt), windowMinutes: def.minutes, kind: def.kind });
+  }
+  return out;
+}
+async function fetchOpenCodeUsage(key) {
+  const res = await fetchJson(USAGE_URL2, { headers: { Authorization: `Bearer ${key}`, Accept: "application/json" } });
+  return { status: res.status, windows: res.status === 200 ? normalizeOpenCodeUsage(res.body) : [] };
+}
+async function fetchOpenCode(account) {
+  try {
+    const key = account.kind === "token" ? await secretStore().get(account.id) : readOpenCodeGoKey();
+    if (!key) {
+      return account.kind === "token" ? snapshot(account, "error", { message: "Stored key missing. Remove and re-add this account." }) : snapshot(account, "signed_out", { message: "No OpenCode Go key found. Run `opencode auth login` or `just-usage add opencode`." });
+    }
+    const { status, windows } = await fetchOpenCodeUsage(key);
+    if (status === 401)
+      return snapshot(account, "error", { message: "Key rejected (401)." });
+    if (status === 403)
+      return snapshot(account, "unsupported", { message: "Valid key, but no active OpenCode Go subscription (403)." });
+    if (status === 429)
+      return snapshot(account, "error", { message: "Rate limited (429). Try again shortly." });
+    if (status !== 200)
+      return snapshot(account, "error", { message: `Usage endpoint returned HTTP ${status}.` });
+    if (windows.length === 0)
+      return snapshot(account, "unsupported", { message: "Usage response had no recognizable windows." });
+    return snapshot(account, "ok", { plan: "go", windows });
+  } catch (e) {
+    return snapshot(account, "error", { message: errorMessage(e) });
+  }
+}
+
+// src/collect.ts
+import { hostname } from "node:os";
+
+// src/adapters/cursor.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
+var USAGE_URL3 = "https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage";
+function authFile() {
+  return process.env.CURSOR_AUTH_FILE ?? join4(homedir4(), ".cursor", "auth.json");
+}
+function readAccessToken() {
+  const file = authFile();
+  if (!existsSync4(file))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync4(file, "utf8"));
+    return typeof parsed.accessToken === "string" && parsed.accessToken ? parsed.accessToken : null;
+  } catch {
+    return null;
+  }
+}
+function jwtExpiry(token) {
+  const part = token.split(".")[1];
+  if (!part)
+    return null;
+  try {
+    const json = Buffer.from(part.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
+    const claims = JSON.parse(json);
+    return typeof claims.exp === "number" ? claims.exp * 1000 : null;
+  } catch {
+    return null;
+  }
+}
+async function cursorEmail() {
+  const res = await run("cursor-agent", ["status"], { timeoutMs: 15000 });
+  const text = stripAnsi(res.stdout + `
+` + res.stderr);
+  const m = text.match(/Logged in as\s+(\S+)/i);
+  return m?.[1] ?? null;
+}
+function cents(v) {
+  if (typeof v === "string" && v.trim())
+    v = Number(v);
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function money(c) {
+  return `$${(c / 100).toFixed(2)}`;
+}
+function normalizeCursorUsage(body) {
+  if (!isObject(body))
+    return null;
+  const cycleEnd = epochToIso(body.billingCycleEnd);
+  const out = [];
+  const plan = isObject(body.planUsage) ? body.planUsage : null;
+  if (plan) {
+    const limit = cents(plan.limit);
+    const included = cents(plan.includedSpend);
+    const bonus = cents(plan.bonusSpend);
+    let used = limit && included !== null ? clampPercent(included / limit * 100) : null;
+    if (used === null)
+      used = clampPercent(plan.totalPercentUsed);
+    if (used !== null) {
+      const parts = [];
+      if (limit !== null && included !== null)
+        parts.push(`${money(included)} of ${money(limit)} included`);
+      if (bonus)
+        parts.push(`${money(bonus)} bonus usage`);
+      if (typeof body.displayMessage === "string" && body.displayMessage.trim())
+        parts.push(body.displayMessage.trim());
+      out.push({ id: "included", label: "Included · billing cycle", usedPercent: used, resetsAt: cycleEnd, windowMinutes: null, kind: "cycle", note: parts.join(" · ") || undefined });
+    }
+    const api = clampPercent(plan.apiPercentUsed);
+    if (api !== null)
+      out.push({ id: "api", label: "Named models", usedPercent: api, resetsAt: cycleEnd, windowMinutes: null, kind: "cycle" });
+    const auto = clampPercent(plan.autoPercentUsed);
+    if (auto !== null)
+      out.push({ id: "auto", label: "Auto models", usedPercent: auto, resetsAt: cycleEnd, windowMinutes: null, kind: "cycle" });
+  }
+  const spend = isObject(body.spendLimitUsage) ? body.spendLimitUsage : null;
+  if (spend) {
+    const indLimit = cents(spend.individualLimit);
+    const indUsed = cents(spend.individualUsed);
+    if (indLimit && indUsed !== null) {
+      out.push({
+        id: "on_demand",
+        label: "On-demand",
+        usedPercent: clampPercent(indUsed / indLimit * 100),
+        resetsAt: cycleEnd,
+        windowMinutes: null,
+        kind: "cycle",
+        note: `${money(indUsed)} of ${money(indLimit)}`
+      });
+    }
+    const poolLimit = cents(spend.pooledLimit);
+    const poolUsed = cents(spend.pooledUsed);
+    if (poolLimit && poolUsed !== null) {
+      out.push({
+        id: "pooled",
+        label: "Team pool",
+        usedPercent: clampPercent(poolUsed / poolLimit * 100),
+        resetsAt: cycleEnd,
+        windowMinutes: null,
+        kind: "cycle",
+        note: `${money(poolUsed)} of ${money(poolLimit)}`
+      });
+    }
+  }
+  return out.length ? out : null;
+}
+async function fetchCursor(account) {
+  try {
+    const token = readAccessToken();
+    if (!token)
+      return snapshot(account, "signed_out", { message: "Not signed in. Run `cursor-agent login`." });
+    const exp = jwtExpiry(token);
+    const emailP = cursorEmail().catch(() => null);
+    if (exp && exp < Date.now()) {
+      return snapshot(account, "error", { email: await emailP, message: "Cursor session expired. Run `cursor-agent login`." });
+    }
+    const res = await fetchJson(USAGE_URL3, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1"
+      },
+      body: "{}"
+    });
+    const email = await emailP;
+    if (res.status === 401 || res.status === 403) {
+      return snapshot(account, "error", { email, message: `Cursor rejected the session (${res.status}). Run \`cursor-agent login\`.` });
+    }
+    if (res.status !== 200) {
+      return snapshot(account, "error", { email, message: `Cursor usage endpoint returned HTTP ${res.status}.` });
+    }
+    const windows = normalizeCursorUsage(res.body);
+    if (!windows) {
+      return snapshot(account, "unsupported", { email, message: "Cursor returned no plan usage for this account (team/enterprise plans are not supported yet)." });
+    }
+    return snapshot(account, "ok", { email, windows });
+  } catch (e) {
+    return snapshot(account, "error", { message: errorMessage(e) });
+  }
+}
+
+// src/adapters/index.ts
+function fetchSnapshot(account) {
+  switch (account.provider) {
+    case "claude":
+      return fetchClaude(account);
+    case "codex":
+      return fetchCodex(account);
+    case "cursor":
+      return fetchCursor(account);
+    case "opencode":
+      return fetchOpenCode(account);
+  }
+}
+
+// src/registry.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync2, rmSync } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
+function readRegistry() {
+  const file = paths.registry();
+  if (!existsSync5(file))
+    return { version: 1, accounts: [] };
+  try {
+    const parsed = JSON.parse(readFileSync5(file, "utf8"));
+    return { version: 1, accounts: Array.isArray(parsed.accounts) ? parsed.accounts : [] };
+  } catch {
+    return { version: 1, accounts: [] };
+  }
+}
+function writeRegistry(reg) {
+  const file = paths.registry();
+  ensureDir(dirname2(file));
+  writeFileSync2(file, JSON.stringify(reg, null, 2) + `
+`, { mode: 384 });
+}
+function listAccounts(provider) {
+  const all = readRegistry().accounts;
+  return provider ? all.filter((a) => a.provider === provider) : all;
+}
+function getAccount(id) {
+  return readRegistry().accounts.find((a) => a.id === id) ?? null;
+}
+function newAccountId(provider, hint) {
+  const existing = new Set(readRegistry().accounts.map((a) => a.id));
+  const base = `${provider}:${slugify(hint)}`;
+  if (base.endsWith(":default"))
+    return newAccountId(provider, `${hint}-2`);
+  if (!existing.has(base))
+    return base;
+  for (let i = 2;; i++) {
+    const candidate = `${base}-${i}`;
+    if (!existing.has(candidate))
+      return candidate;
+  }
+}
+function profileDirFor(provider, id) {
+  return join5(paths.profiles(provider), id.split(":")[1] ?? "account");
+}
+function saveAccount(record) {
+  const reg = readRegistry();
+  reg.accounts = reg.accounts.filter((a) => a.id !== record.id);
+  reg.accounts.push(record);
+  writeRegistry(reg);
+}
+function updateAccount(id, patch) {
+  const reg = readRegistry();
+  const idx = reg.accounts.findIndex((a) => a.id === id);
+  if (idx === -1)
+    return;
+  reg.accounts[idx] = { ...reg.accounts[idx], ...patch, id };
+  writeRegistry(reg);
+}
+function deleteAccount(id) {
+  const reg = readRegistry();
+  const record = reg.accounts.find((a) => a.id === id) ?? null;
+  if (!record)
+    return null;
+  reg.accounts = reg.accounts.filter((a) => a.id !== id);
+  writeRegistry(reg);
+  if (record.kind === "profile" && record.path && record.path.startsWith(paths.profiles(record.provider))) {
+    rmSync(record.path, { recursive: true, force: true });
+  }
+  return record;
+}
+
+// src/types.ts
+var PROVIDERS = [
+  { id: "claude", name: "Claude", bin: "claude" },
+  { id: "codex", name: "Codex", bin: "codex" },
+  { id: "cursor", name: "Cursor", bin: "cursor-agent" },
+  { id: "opencode", name: "OpenCode Go", bin: "opencode" }
+];
+function providerName(id) {
+  return PROVIDERS.find((p) => p.id === id)?.name ?? id;
+}
+
+// src/collect.ts
+async function detectProviders() {
+  return Promise.all(PROVIDERS.map(async (p) => {
+    const path = await which(p.bin);
+    const version = path ? await binVersion(p.bin) : null;
+    return { id: p.id, installed: path !== null, version };
+  }));
+}
+function resolveAccounts(provider, installed) {
+  const out = [];
+  if (installed || provider === "opencode") {
+    out.push({ id: `${provider}:default`, provider, label: "Default", kind: "default" });
+  }
+  for (const rec of listAccounts(provider)) {
+    out.push({ id: rec.id, provider, label: rec.label, kind: rec.kind, path: rec.path, email: rec.email ?? null });
+  }
+  return out;
+}
+async function fetchAccount(account) {
+  try {
+    return await withTimeout(fetchSnapshot(account), FETCH_TIMEOUT_MS, `${account.provider} fetch`);
+  } catch (e) {
+    return snapshot(account, "error", { message: e instanceof Error ? e.message : String(e) });
+  }
+}
+async function collectReport(update, only) {
+  const presence = await detectProviders();
+  const providers = await Promise.all(PROVIDERS.filter((p) => !only || only.includes(p.id)).map(async (p) => {
+    const pres = presence.find((x) => x.id === p.id);
+    const accounts = resolveAccounts(p.id, pres.installed);
+    const snapshots = await Promise.all(accounts.map(fetchAccount));
+    return { id: p.id, name: p.name, installed: pres.installed, version: pres.version, accounts: snapshots };
+  }));
+  return {
+    version: VERSION,
+    hostname: hostname().replace(/\.local$/, ""),
+    fetchedAt: new Date().toISOString(),
+    update,
+    providers
+  };
+}
+
+class ReportCache {
+  ttlMs;
+  getUpdate;
+  report = null;
+  inflight = null;
+  constructor(ttlMs, getUpdate) {
+    this.ttlMs = ttlMs;
+    this.getUpdate = getUpdate;
+  }
+  get(force = false) {
+    if (this.inflight)
+      return this.inflight;
+    if (!force && this.report && Date.now() - Date.parse(this.report.fetchedAt) < this.ttlMs) {
+      return Promise.resolve({ ...this.report, update: this.getUpdate() });
+    }
+    this.inflight = collectReport(this.getUpdate()).then((r) => {
+      this.report = r;
+      return r;
+    }).finally(() => {
+      this.inflight = null;
+    });
+    return this.inflight;
+  }
+  peek() {
+    return this.report ? { ...this.report, update: this.getUpdate() } : null;
+  }
+}
+
+// src/server.ts
+import { createServer } from "node:http";
+import { hostname as hostname2, networkInterfaces } from "node:os";
+
+// src/ui/index.html
+var ui_default = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<meta name="color-scheme" content="dark">
+<title>just-usage</title>
+<link rel="icon" type="image/svg+xml" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='7' fill='%23000'/%3E%3Crect x='7' y='14' width='18' height='4' rx='2' fill='%232a2a2a'/%3E%3Crect x='7' y='14' width='11' height='4' rx='2' fill='%23fff'/%3E%3C/svg%3E">
+<style>
+  :root {
+    --bg: #000;
+    --surface: #0b0b0b;
+    --line: #1c1c1c;
+    --line-2: #2a2a2a;
+    --fg: #ececec;
+    --muted: #8b8b8b;
+    --dim: #4d4d4d;
+    --ok: #ffffff;
+    --warn: #f5c542;
+    --crit: #ff4a4a;
+  }
+  * { box-sizing: border-box; }
+  html, body {
+    margin: 0;
+    background: var(--bg);
+    color: var(--fg);
+    font: 14px/1.45 -apple-system, BlinkMacSystemFont, "Inter", "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+    -webkit-font-smoothing: antialiased;
+  }
+  .mono { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-variant-numeric: tabular-nums; }
+  .wrap { max-width: 820px; margin: 0 auto; padding: 44px 20px 64px; }
+
+  header { display: flex; align-items: baseline; justify-content: space-between; margin-bottom: 26px; gap: 16px; }
+  h1 { font-size: 15px; font-weight: 500; letter-spacing: .01em; margin: 0; }
+  h1 span { color: var(--dim); font-weight: 400; margin-left: 8px; }
+  .meta { color: var(--muted); font-size: 12px; display: flex; gap: 14px; align-items: center; }
+  button.refresh {
+    background: transparent; color: var(--fg); border: 1px solid var(--line-2); border-radius: 6px;
+    padding: 5px 11px; font: inherit; font-size: 12px; cursor: pointer;
+  }
+  button.refresh:hover { border-color: #3a3a3a; }
+  button.refresh[disabled] { opacity: .45; cursor: default; }
+
+  /* Chrome-style tab strip */
+  .tabs { display: flex; gap: 2px; padding: 0 8px; position: relative; z-index: 1; }
+  .tab {
+    position: relative; background: transparent; border: 1px solid transparent; border-bottom: none;
+    border-radius: 10px 10px 0 0; color: var(--muted); padding: 9px 16px 9px 14px; cursor: pointer;
+    font: inherit; font-size: 13px; display: flex; gap: 9px; align-items: center; user-select: none;
+    transition: color .12s;
+  }
+  .tab:hover { color: var(--fg); background: #060606; }
+  .tab.active { background: var(--surface); border-color: var(--line); color: var(--fg); margin-bottom: -1px; padding-bottom: 10px; }
+  .tab.active::before, .tab.active::after {
+    content: ""; position: absolute; bottom: 0; width: 10px; height: 10px; background: var(--surface);
+  }
+  .tab.active::before { left: -10px; -webkit-mask: radial-gradient(circle at 0 0, transparent 10px, #000 10.5px); mask: radial-gradient(circle at 0 0, transparent 10px, #000 10.5px); }
+  .tab.active::after { right: -10px; -webkit-mask: radial-gradient(circle at 100% 0, transparent 10px, #000 10.5px); mask: radial-gradient(circle at 100% 0, transparent 10px, #000 10.5px); }
+  .dot { width: 6px; height: 6px; border-radius: 50%; background: var(--dim); flex: none; }
+  .dot.ok { background: var(--ok); } .dot.warn { background: var(--warn); } .dot.crit { background: var(--crit); }
+  .tab .n { color: var(--dim); font-size: 11px; }
+
+  .panel { background: var(--surface); border: 1px solid var(--line); border-radius: 10px; min-height: 160px; }
+  .card { padding: 18px 18px 20px; border-bottom: 1px solid var(--line); }
+  .card:last-child { border-bottom: none; }
+  .card-head { display: flex; justify-content: space-between; align-items: baseline; gap: 12px; }
+  .label { font-weight: 500; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .plan { color: var(--muted); font-size: 12px; text-transform: capitalize; margin-left: 8px; font-weight: 400; }
+  .badge { font-size: 11px; color: var(--muted); border: 1px solid var(--line-2); border-radius: 999px; padding: 1px 8px; white-space: nowrap; }
+  .badge.crit { color: var(--crit); border-color: rgba(255,74,74,.35); }
+  .badge.warn { color: var(--warn); border-color: rgba(245,197,66,.35); }
+
+  .win { margin-top: 14px; }
+  .win-row { display: flex; justify-content: space-between; align-items: baseline; font-size: 12px; color: var(--muted); margin-bottom: 7px; gap: 12px; }
+  .win-row b { color: var(--fg); font-weight: 500; }
+  .win-row .pct { color: var(--fg); }
+  .win-row .pct.warn { color: var(--warn); } .win-row .pct.crit { color: var(--crit); }
+  .track { height: 4px; background: var(--line); border-radius: 2px; overflow: hidden; }
+  .fill { height: 100%; border-radius: 2px; background: var(--ok); width: 0; transition: width .5s cubic-bezier(.2,.7,.2,1); }
+  .fill.warn { background: var(--warn); } .fill.crit { background: var(--crit); }
+  .note { color: var(--dim); font-size: 11px; margin-top: 5px; }
+
+  .msg { color: var(--muted); font-size: 13px; margin-top: 6px; }
+  .empty { padding: 46px 18px; color: var(--muted); text-align: center; font-size: 13px; }
+  .hint { color: var(--dim); font-size: 12px; margin-top: 8px; }
+  code { font-family: ui-monospace, Menlo, Consolas, monospace; background: #121212; padding: 1px 6px; border-radius: 4px; font-size: 12px; color: var(--fg); }
+  .credits { font-size: 12px; color: var(--muted); margin-top: 16px; padding-top: 12px; border-top: 1px dashed var(--line); }
+
+  footer { margin-top: 26px; color: var(--dim); font-size: 12px; display: flex; justify-content: space-between; gap: 12px; flex-wrap: wrap; }
+  footer .update { color: var(--warn); }
+  footer kbd { font-family: inherit; color: var(--dim); }
+  @media (max-width: 520px) {
+    .wrap { padding: 28px 12px 48px; }
+    .tab { padding: 8px 11px; font-size: 12px; }
+    .tab .n { display: none; }
+  }
+</style>
+</head>
+<body>
+<div class="wrap">
+  <header>
+    <h1>just-usage<span id="host"></span></h1>
+    <div class="meta">
+      <span id="updated" class="mono"></span>
+      <button class="refresh" id="refresh" type="button">Refresh</button>
+    </div>
+  </header>
+  <nav class="tabs" id="tabs" role="tablist"></nav>
+  <section class="panel" id="panel" role="tabpanel"><div class="empty">Loading…</div></section>
+  <footer>
+    <span id="version"></span>
+    <span id="update"></span>
+  </footer>
+</div>
+
+<script>
+(() => {
+  const PROVIDERS = [
+    ["claude", "Claude"],
+    ["codex", "Codex"],
+    ["cursor", "Cursor"],
+    ["opencode", "OpenCode Go"],
+  ];
+  const SIGNIN_HINT = {
+    claude: "Run <code>claude</code>, then <code>/login</code>.",
+    codex: "Run <code>codex login</code>.",
+    cursor: "Run <code>cursor-agent login</code>.",
+    opencode: "Run <code>opencode auth login</code> or <code>just-usage add opencode</code>.",
+  };
+  const $ = (id) => document.getElementById(id);
+  let report = null;
+  const wanted = new URLSearchParams(location.search).get("tab");
+  let active = PROVIDERS.some(([id]) => id === wanted) ? wanted : localStorage.getItem("ju.tab") || "claude";
+  let loading = false;
+
+  const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+  // Escape, then turn \`backticked\` spans into <code>.
+  const rich = (s) => esc(s).replace(/\`([^\`]+)\`/g, "<code>$1</code>");
+  const sev = (p) => (p == null ? null : p >= 85 ? "crit" : p >= 60 ? "warn" : "ok");
+  const rank = { ok: 1, warn: 2, crit: 3 };
+
+  function fmtDuration(ms) {
+    const min = Math.round(ms / 60000);
+    const d = Math.floor(min / 1440), h = Math.floor((min % 1440) / 60), m = min % 60;
+    if (d > 0) return h ? \`\${d}d \${h}h\` : \`\${d}d\`;
+    if (h > 0) return m ? \`\${h}h \${m}m\` : \`\${h}h\`;
+    return \`\${Math.max(1, m)}m\`;
+  }
+  function fmtReset(w) {
+    if (!w.resetsAt) return "";
+    const t = Date.parse(w.resetsAt);
+    if (!isFinite(t)) return "";
+    const diff = t - Date.now();
+    if (w.kind === "cycle") {
+      const date = new Date(t).toLocaleDateString(undefined, { month: "short", day: "numeric" });
+      return diff <= 0 ? "renewing" : \`renews \${date}\`;
+    }
+    return diff <= 0 ? "resetting" : \`resets in \${fmtDuration(diff)}\`;
+  }
+  function fmtTime(iso) {
+    const t = Date.parse(iso);
+    return isFinite(t) ? new Date(t).toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit" }) : "";
+  }
+
+  function providerSeverity(p) {
+    if (!p) return null;
+    let worst = null;
+    for (const a of p.accounts) {
+      if (a.status !== "ok") continue;
+      for (const w of a.windows) {
+        const s = sev(w.usedPercent);
+        if (s && (!worst || rank[s] > rank[worst])) worst = s;
+      }
+    }
+    return worst;
+  }
+
+  function renderTabs() {
+    $("tabs").innerHTML = PROVIDERS.map(([id, name]) => {
+      const p = report?.providers.find((x) => x.id === id);
+      const s = providerSeverity(p);
+      const n = p ? p.accounts.filter((a) => a.status === "ok").length : 0;
+      return \`<button class="tab\${id === active ? " active" : ""}" role="tab" data-id="\${id}" aria-selected="\${id === active}">
+        <span class="dot\${s ? " " + s : ""}"></span>\${esc(name)}\${n > 1 ? \`<span class="n">\${n}</span>\` : ""}</button>\`;
+    }).join("");
+    for (const el of $("tabs").querySelectorAll(".tab")) {
+      el.onclick = () => { active = el.dataset.id; localStorage.setItem("ju.tab", active); render(); };
+    }
+  }
+
+  function renderWindow(w) {
+    const s = sev(w.usedPercent);
+    const pct = w.usedPercent == null ? "—" : \`\${Math.round(w.usedPercent)}%\`;
+    const reset = fmtReset(w);
+    return \`<div class="win">
+      <div class="win-row"><b>\${esc(w.label)}</b>
+        <span class="mono"><span class="pct\${s ? " " + s : ""}">\${pct} used</span>\${reset ? \` · \${esc(reset)}\` : ""}</span></div>
+      <div class="track"><div class="fill\${s ? " " + s : ""}" style="width:\${w.usedPercent ?? 0}%"></div></div>
+      \${w.note ? \`<div class="note">\${esc(w.note)}</div>\` : ""}
+    </div>\`;
+  }
+
+  function renderCard(a, provider) {
+    const title = a.account.email || a.account.label;
+    const sub = a.account.email && a.account.label !== "Default" && a.account.label !== a.account.email ? \` <span class="plan">\${esc(a.account.label)}</span>\` : "";
+    const plan = a.account.plan ? \`<span class="plan">\${esc(a.account.plan)}</span>\` : "";
+    let badge = "";
+    if (a.status === "ok") {
+      let worst = null;
+      for (const w of a.windows) { const s = sev(w.usedPercent); if (s && (!worst || rank[s] > rank[worst])) worst = s; }
+      if (worst === "crit") badge = \`<span class="badge crit">critical</span>\`;
+      else if (worst === "warn") badge = \`<span class="badge warn">running low</span>\`;
+    } else {
+      const text = { signed_out: "signed out", unsupported: "unsupported", error: "error" }[a.status] || a.status;
+      badge = \`<span class="badge">\${esc(text)}</span>\`;
+    }
+    let body = "";
+    if (a.status === "ok") {
+      body = a.windows.map(renderWindow).join("");
+      if (a.resetCredits && a.resetCredits.availableCount > 0) {
+        const c = a.resetCredits.credits.find((x) => x.status === "available") || a.resetCredits.credits[0];
+        const exp = c && c.expiresAt ? \` · expires \${new Date(c.expiresAt).toLocaleDateString(undefined, { month: "short", day: "numeric" })}\` : "";
+        const n = a.resetCredits.availableCount;
+        body += \`<div class="credits">\${n} rate-limit reset\${n === 1 ? "" : "s"} banked\${c && c.title ? \` — \${esc(c.title)}\` : ""}\${exp}</div>\`;
+      }
+    } else {
+      body = a.message ? \`<div class="msg">\${rich(a.message)}</div>\` : \`<div class="hint">\${SIGNIN_HINT[provider] || ""}</div>\`;
+    }
+    return \`<article class="card">
+      <div class="card-head"><div class="label">\${esc(title)}\${sub}\${plan}</div>\${badge}</div>
+      \${body}
+    </article>\`;
+  }
+
+  function renderPanel() {
+    const p = report?.providers.find((x) => x.id === active);
+    const name = PROVIDERS.find(([id]) => id === active)?.[1] || active;
+    if (!p) { $("panel").innerHTML = \`<div class="empty">Loading…</div>\`; return; }
+    if (!p.installed && p.accounts.length === 0) {
+      $("panel").innerHTML = \`<div class="empty">\${esc(name)} isn't installed on \${esc(report.hostname)}.</div>\`;
+      return;
+    }
+    if (p.accounts.length === 0) {
+      $("panel").innerHTML = \`<div class="empty">No \${esc(name)} accounts.<div class="hint">\${SIGNIN_HINT[active] || ""}</div></div>\`;
+      return;
+    }
+    $("panel").innerHTML = p.accounts.map((a) => renderCard(a, active)).join("");
+  }
+
+  function render() {
+    renderTabs();
+    renderPanel();
+    if (report) {
+      $("host").textContent = report.hostname;
+      $("updated").textContent = loading ? "refreshing…" : \`updated \${fmtTime(report.fetchedAt)}\`;
+      $("version").textContent = \`v\${report.version}\`;
+      const u = report.update;
+      $("update").innerHTML = u && u.available
+        ? \`<span class="update">v\${esc(u.latest)} available — run <code>just-usage upgrade</code></span>\`
+        : \`<kbd>1</kbd>–<kbd>4</kbd> switch tabs · <kbd>r</kbd> refresh\`;
+    }
+    $("refresh").disabled = loading;
+  }
+
+  async function load(force) {
+    loading = true;
+    render();
+    try {
+      const res = await fetch(\`/api/quotas\${force ? "?refresh=1" : ""}\`, { cache: "no-store" });
+      report = await res.json();
+    } catch (e) {
+      $("panel").innerHTML = \`<div class="empty">Couldn't reach just-usage. Is the server still running?</div>\`;
+    } finally {
+      loading = false;
+      render();
+    }
+  }
+
+  $("refresh").onclick = () => load(true);
+  document.addEventListener("keydown", (e) => {
+    if (e.metaKey || e.ctrlKey || e.altKey) return;
+    if (e.key >= "1" && e.key <= "4") { active = PROVIDERS[Number(e.key) - 1][0]; localStorage.setItem("ju.tab", active); render(); }
+    else if (e.key === "r") load(true);
+  });
+  setInterval(() => { if (report && !loading) render(); }, 30000);
+  load(false);
+})();
+</script>
+</body>
+</html>
+`;
+
+// src/server.ts
+function json(res, status, body) {
+  const text = JSON.stringify(body);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store",
+    "Content-Length": Buffer.byteLength(text)
+  });
+  res.end(text);
+}
+function startServer(opts) {
+  const cache = new ReportCache(CACHE_TTL_MS, opts.getUpdate);
+  cache.get(true).catch(() => {});
+  const handler = async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    try {
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        json(res, 405, { error: "method not allowed" });
+        return;
+      }
+      if (url.pathname === "/") {
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
+        res.end(ui_default);
+        return;
+      }
+      if (url.pathname === "/api/quotas") {
+        const force = url.searchParams.get("refresh") === "1";
+        json(res, 200, await cache.get(force));
+        return;
+      }
+      if (url.pathname === "/api/health") {
+        json(res, 200, { ok: true, version: VERSION });
+        return;
+      }
+      json(res, 404, { error: "not found" });
+    } catch (e) {
+      json(res, 500, { error: e instanceof Error ? e.message : String(e) });
+    }
+  };
+  const server = createServer((req, res) => void handler(req, res));
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(opts.port, opts.host, () => {
+      resolve({ close: () => server.close(), urls: reachableUrls(opts.host, opts.port) });
+    });
+  });
+}
+function isTailscale(ip) {
+  const [a, b] = ip.split(".").map(Number);
+  return a === 100 && b !== undefined && b >= 64 && b <= 127;
+}
+function reachableUrls(host, port) {
+  if (host !== "0.0.0.0" && host !== "::")
+    return [`http://${host === "::1" ? "localhost" : host}:${port}`];
+  const urls = [`http://127.0.0.1:${port}`];
+  const shortHost = hostname2().replace(/\.local$/, "").toLowerCase();
+  if (shortHost)
+    urls.push(`http://${shortHost}:${port}`);
+  const seen = new Set;
+  for (const list of Object.values(networkInterfaces())) {
+    for (const iface of list ?? []) {
+      if (iface.family !== "IPv4" || iface.internal || seen.has(iface.address))
+        continue;
+      seen.add(iface.address);
+      urls.push(`http://${iface.address}:${port}${isTailscale(iface.address) ? "  (tailscale)" : ""}`);
+    }
+  }
+  return urls;
+}
+
+// src/terminal.ts
+var useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+var c = {
+  dim: (s) => useColor ? `\x1B[2m${s}\x1B[0m` : s,
+  bold: (s) => useColor ? `\x1B[1m${s}\x1B[0m` : s,
+  yellow: (s) => useColor ? `\x1B[33m${s}\x1B[0m` : s,
+  red: (s) => useColor ? `\x1B[31m${s}\x1B[0m` : s
+};
+function bar(used, width = 20) {
+  if (used === null)
+    return c.dim("░".repeat(width));
+  const filled = Math.round(used / 100 * width);
+  const s = "█".repeat(filled) + c.dim("░".repeat(width - filled));
+  const sev = severity(used);
+  return sev === "crit" ? c.red(s) : sev === "warn" ? c.yellow(s) : s;
+}
+function pct(used) {
+  if (used === null)
+    return "  —  ";
+  const s = `${String(Math.round(used)).padStart(3)}%`;
+  const sev = severity(used);
+  return sev === "crit" ? c.red(s) : sev === "warn" ? c.yellow(s) : s;
+}
+function renderAccount(a, now) {
+  const lines = [];
+  const title = a.account.email ?? a.account.label;
+  const extras = [a.account.label !== "Default" && a.account.label !== title ? a.account.label : null, a.account.plan].filter(Boolean).join(" · ");
+  lines.push(`  ${c.bold(title)}${extras ? c.dim(`  ${extras}`) : ""}`);
+  if (a.status !== "ok") {
+    lines.push(`    ${c.dim(a.status.replace("_", " "))}  ${a.message ?? ""}`);
+    return lines;
+  }
+  const labelWidth = Math.max(6, ...a.windows.map((w) => w.label.length));
+  for (const w of a.windows) {
+    const reset = formatResetIn(w.resetsAt, now, w.kind);
+    lines.push(`    ${w.label.padEnd(labelWidth)}  ${bar(w.usedPercent)}  ${pct(w.usedPercent)} used${reset ? c.dim(`  ${reset}`) : ""}`);
+  }
+  if (a.resetCredits && a.resetCredits.availableCount > 0) {
+    lines.push(`    ${c.dim(`${a.resetCredits.availableCount} rate-limit reset(s) banked`)}`);
+  }
+  return lines;
+}
+function renderReport(report, now = Date.now()) {
+  const out = [];
+  for (const p of report.providers) {
+    out.push(`${c.bold(p.name)}${p.version ? c.dim(`  v${p.version}`) : ""}${p.installed ? "" : c.dim("  not installed")}`);
+    if (p.accounts.length === 0)
+      out.push(c.dim("  no accounts"));
+    for (const a of p.accounts)
+      out.push(...renderAccount(a, now));
+    out.push("");
+  }
+  if (report.update?.available) {
+    out.push(c.yellow(`Update available: v${report.update.current} → v${report.update.latest}. Run: just-usage upgrade`));
+  }
+  return out.join(`
+`);
+}
+
+// src/update.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+var CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
+function readCache() {
+  const file = paths.updateCache();
+  if (!existsSync6(file))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync6(file, "utf8"));
+    if (typeof parsed.checkedAt === "string" && typeof parsed.latest === "string")
+      return parsed;
+  } catch {}
+  return null;
+}
+function writeCache(c2) {
+  try {
+    ensureDir(dirname3(paths.updateCache()));
+    writeFileSync3(paths.updateCache(), JSON.stringify(c2) + `
+`);
+  } catch {}
+}
+async function latestFromGitHub() {
+  const res = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, {
+    headers: { Accept: "application/vnd.github+json", "User-Agent": `${PACKAGE_NAME}/${VERSION}` },
+    signal: AbortSignal.timeout(6000)
+  });
+  if (!res.ok)
+    return null;
+  const body = await res.json();
+  const tag = body.tag_name?.replace(/^v/, "");
+  return tag && /^\d+\.\d+\.\d+/.test(tag) ? tag : null;
+}
+async function latestFromNpm() {
+  const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+    headers: { Accept: "application/json", "User-Agent": `${PACKAGE_NAME}/${VERSION}` },
+    signal: AbortSignal.timeout(6000)
+  });
+  if (!res.ok)
+    return null;
+  const body = await res.json();
+  return body.version && /^\d+\.\d+\.\d+/.test(body.version) ? body.version : null;
+}
+async function checkForUpdate(force = false) {
+  if (process.env.JUST_USAGE_NO_UPDATE_CHECK === "1" && !force)
+    return null;
+  const cached = readCache();
+  if (!force && cached && Date.now() - Date.parse(cached.checkedAt) < CHECK_INTERVAL_MS) {
+    return toInfo(cached);
+  }
+  let latest = null;
+  try {
+    latest = await latestFromGitHub();
+  } catch {
+    latest = null;
+  }
+  if (!latest) {
+    try {
+      latest = await latestFromNpm();
+    } catch {
+      latest = null;
+    }
+  }
+  if (!latest)
+    return cached ? toInfo(cached) : null;
+  const entry = { checkedAt: new Date().toISOString(), latest };
+  writeCache(entry);
+  return toInfo(entry);
+}
+function toInfo(c2) {
+  return { current: VERSION, latest: c2.latest, available: semverGt(c2.latest, VERSION), checkedAt: c2.checkedAt };
+}
+function detectPackageManager(argv1 = process.argv[1] ?? "", execPath = process.execPath) {
+  const p = argv1.replace(/\\/g, "/");
+  if (/\/\.bun\//.test(p) || /bun/.test(execPath.replace(/\\/g, "/").split("/").pop() ?? ""))
+    return "bun";
+  if (/\/pnpm\//.test(p) || /\/\.pnpm\//.test(p))
+    return "pnpm";
+  if (/\/\.yarn\//.test(p) || /\/yarn\//.test(p))
+    return "yarn";
+  return "npm";
+}
+function upgradeCommand(pm, version = "latest") {
+  const spec = `${PACKAGE_NAME}@${version}`;
+  switch (pm) {
+    case "bun":
+      return ["bun", ["add", "-g", spec]];
+    case "pnpm":
+      return ["pnpm", ["add", "-g", spec]];
+    case "yarn":
+      return ["yarn", ["global", "add", spec]];
+    default:
+      return ["npm", ["install", "-g", spec]];
+  }
+}
+async function runUpgrade(pm, version = "latest") {
+  const [cmd, args] = upgradeCommand(pm, version);
+  console.log(`$ ${cmd} ${args.join(" ")}`);
+  return runInteractive(cmd, args);
+}
+
+// src/cli.ts
+var HELP = `${PACKAGE_NAME} v${VERSION}
+One local page for your coding-CLI subscription quotas.
+
+Usage
+  just-usage                     Start the server and open the page
+  just-usage serve [options]     Start the server
+      --port <n>                 Port (default ${DEFAULT_PORT})
+      --host <addr>              Bind address (default ${DEFAULT_HOST}; use 127.0.0.1 for local only)
+      --no-open                  Don't open a browser
+  just-usage status [--json]     Print quotas in the terminal
+  just-usage accounts            List accounts
+  just-usage add <provider>      Add an account (codex | claude | opencode)
+      --label <name>             Friendly name
+      --token                    Claude only: paste a \`claude setup-token\` instead of a profile login
+  just-usage login <account-id>  Re-authenticate a profile account
+  just-usage remove <account-id> Remove an account and anything we stored for it
+  just-usage upgrade [--check]   Update to the latest release
+  just-usage --version
+
+Providers: ${PROVIDERS.map((p) => p.name).join(", ")}
+Cursor uses whatever \`cursor-agent\` is logged in as (single account).
+`;
+function fail(msg, code = 1) {
+  console.error(msg);
+  process.exit(code);
+}
+function isProvider(v) {
+  return PROVIDERS.some((p) => p.id === v);
+}
+async function prompt(question, opts = {}) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout, terminal: process.stdin.isTTY });
+  const muted = opts.secret && process.stdin.isTTY;
+  return new Promise((resolve) => {
+    if (muted) {
+      process.stdout.write(question);
+      const anyRl = rl;
+      anyRl._writeToOutput = (s) => {
+        if (s.includes(`
+`))
+          process.stdout.write(`
+`);
+      };
+      rl.question("", (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    }
+  });
+}
+async function cmdServe(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      port: { type: "string", short: "p" },
+      host: { type: "string" },
+      "no-open": { type: "boolean" },
+      open: { type: "boolean" }
+    },
+    allowPositionals: true,
+    strict: false
+  });
+  const port = values.port ? Number(values.port) : DEFAULT_PORT;
+  if (!Number.isInteger(port) || port <= 0 || port > 65535)
+    fail(`invalid port: ${values.port}`);
+  const host = typeof values.host === "string" && values.host ? values.host : DEFAULT_HOST;
+  const shouldOpen = values["no-open"] !== true && values.open !== false;
+  let update = null;
+  checkForUpdate().then((u) => {
+    update = u;
+    if (u?.available)
+      console.log(`
+Update available: v${u.current} → v${u.latest}. Run: just-usage upgrade
+`);
+  });
+  let server;
+  try {
+    server = await startServer({ host, port, getUpdate: () => update });
+  } catch (e) {
+    const code = e.code;
+    if (code === "EADDRINUSE")
+      fail(`Port ${port} is already in use. Try: just-usage serve --port ${port + 1}`);
+    throw e;
+  }
+  console.log(`${PACKAGE_NAME} v${VERSION}`);
+  for (const [i, url] of server.urls.entries())
+    console.log(`  ${i === 0 ? "local   " : "network "} ${url}`);
+  console.log(`
+Press Ctrl+C to stop.`);
+  if (shouldOpen)
+    openInBrowser(server.urls[0]);
+  const shutdown = () => {
+    server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+async function cmdStatus(argv) {
+  const { values } = parseArgs({ args: argv, options: { json: { type: "boolean" } }, allowPositionals: true, strict: false });
+  const [report, update] = await Promise.all([collectReport(null), checkForUpdate().catch(() => null)]);
+  report.update = update;
+  if (values.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  console.log(renderReport(report));
+}
+function cmdAccounts() {
+  const rows = listAccounts();
+  console.log("Default accounts come from each CLI's own login (codex login, claude /login, cursor-agent login, opencode auth login).");
+  if (rows.length === 0) {
+    console.log(`
+No extra accounts. Add one with: just-usage add codex | claude | opencode`);
+    return;
+  }
+  console.log("");
+  const w = Math.max(...rows.map((r) => r.id.length));
+  for (const r of rows) {
+    const extra = [r.email, r.kind, r.path].filter(Boolean).join("  ");
+    console.log(`  ${r.id.padEnd(w)}  ${r.label}  ${extra}`);
+  }
+}
+async function addCodex(label) {
+  if (!await which("codex"))
+    fail("codex is not installed (npm i -g @openai/codex).");
+  const tmpId = newAccountId("codex", label ?? "pending");
+  const dir = ensureDir(profileDirFor("codex", tmpId));
+  console.log("Starting Codex login in an isolated profile…");
+  const info = await codexLogin(dir, (url) => {
+    console.log(`
+Open this URL to sign in (opening your browser):
+${url}
+`);
+    openInBrowser(url);
+  });
+  const finalLabel = label ?? info.email ?? tmpId.split(":")[1];
+  const id = label ? tmpId : newAccountId("codex", finalLabel);
+  const path = id === tmpId ? dir : ensureDir(profileDirFor("codex", id));
+  if (path !== dir) {
+    const { renameSync, rmSync: rmSync2 } = await import("node:fs");
+    rmSync2(path, { recursive: true, force: true });
+    renameSync(dir, path);
+  }
+  saveAccount({ id, provider: "codex", label: finalLabel, kind: "profile", path, email: info.email, createdAt: new Date().toISOString() });
+  console.log(`Added ${id}${info.email ? ` (${info.email}${info.plan ? `, ${info.plan}` : ""})` : ""}.`);
+}
+async function addClaudeToken(label) {
+  console.log("Run `claude setup-token` in the account you want to add, then paste the token here.");
+  const token = await prompt("Token: ", { secret: true });
+  if (!token)
+    fail("No token given.");
+  const check = await verifyClaudeToken(token);
+  if (!check.ok)
+    fail(`Token check failed: ${check.message}`);
+  const finalLabel = label ?? check.email ?? "token";
+  const id = newAccountId("claude", finalLabel);
+  await secretStore().set(id, token);
+  saveAccount({ id, provider: "claude", label: finalLabel, kind: "token", email: check.email, createdAt: new Date().toISOString() });
+  console.log(`Added ${id}${check.email ? ` (${check.email})` : ""}. Token stored in ${secretStore().kind}.`);
+}
+async function addClaudeProfile(label) {
+  if (!await which("claude"))
+    fail("claude is not installed (npm i -g @anthropic-ai/claude-code).");
+  const id = newAccountId("claude", label ?? "profile");
+  const dir = ensureDir(profileDirFor("claude", id));
+  console.log(`Starting Claude Code login in an isolated profile (CLAUDE_CONFIG_DIR=${dir})…
+`);
+  await runInteractive("claude", ["auth", "login"], { CLAUDE_CONFIG_DIR: dir });
+  const status = await claudeAuthStatus(dir);
+  if (!status?.loggedIn) {
+    const { rmSync: rmSync2 } = await import("node:fs");
+    rmSync2(dir, { recursive: true, force: true });
+    fail("Login did not complete; nothing was saved.");
+  }
+  saveAccount({ id, provider: "claude", label: label ?? id.split(":")[1], kind: "profile", path: dir, email: null, createdAt: new Date().toISOString() });
+  console.log(`
+Added ${id}. Note: on macOS the first read may trigger a Keychain prompt — choose "Always Allow".`);
+}
+async function addOpenCode(label) {
+  console.log("Paste an OpenCode Go API key (from https://opencode.ai/ → Go → API keys).");
+  const key = await prompt("Key: ", { secret: true });
+  if (!key)
+    fail("No key given.");
+  const { status, windows } = await fetchOpenCodeUsage(key);
+  if (status === 401)
+    fail("Key rejected (401).");
+  if (status === 403)
+    console.log("Warning: key is valid but has no active OpenCode Go subscription (403). Saving anyway.");
+  else if (status !== 200)
+    fail(`Usage endpoint returned HTTP ${status}.`);
+  const finalLabel = label ?? "go";
+  const id = newAccountId("opencode", finalLabel);
+  await secretStore().set(id, key);
+  saveAccount({ id, provider: "opencode", label: finalLabel, kind: "token", createdAt: new Date().toISOString() });
+  console.log(`Added ${id}${windows.length ? ` (${windows.map((w) => `${w.label} ${w.usedPercent}%`).join(", ")})` : ""}. Key stored in ${secretStore().kind}.`);
+}
+async function cmdAdd(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: { label: { type: "string", short: "l" }, token: { type: "boolean" } },
+    allowPositionals: true
+  });
+  const provider = positionals[0];
+  if (!isProvider(provider))
+    fail(`Usage: just-usage add <codex|claude|opencode> [--label name] [--token]`);
+  switch (provider) {
+    case "codex":
+      return addCodex(values.label);
+    case "claude":
+      return values.token ? addClaudeToken(values.label) : addClaudeProfile(values.label);
+    case "opencode":
+      return addOpenCode(values.label);
+    case "cursor":
+      fail("Cursor is single-account: just-usage shows whatever `cursor-agent` is logged in as.");
+  }
+}
+async function cmdLogin(argv) {
+  const id = argv[0];
+  if (!id)
+    fail("Usage: just-usage login <account-id>");
+  const rec = getAccount(id);
+  if (!rec)
+    fail(`Unknown account: ${id}`);
+  if (rec.kind !== "profile" || !rec.path)
+    fail(`${id} is a ${rec.kind} account; remove and re-add it instead.`);
+  if (rec.provider === "codex") {
+    const info = await codexLogin(rec.path, (url) => {
+      console.log(`
+Open this URL to sign in (opening your browser):
+${url}
+`);
+      openInBrowser(url);
+    });
+    updateAccount(id, { email: info.email });
+    console.log(`Re-authenticated ${id}${info.email ? ` (${info.email})` : ""}.`);
+  } else if (rec.provider === "claude") {
+    await runInteractive("claude", ["auth", "login"], { CLAUDE_CONFIG_DIR: rec.path });
+    const status = await claudeAuthStatus(rec.path);
+    console.log(status?.loggedIn ? `Re-authenticated ${id}.` : "Login did not complete.");
+  } else {
+    fail(`${providerName(rec.provider)} accounts cannot be re-authenticated this way.`);
+  }
+}
+async function cmdRemove(argv) {
+  const id = argv[0];
+  if (!id)
+    fail("Usage: just-usage remove <account-id>");
+  if (id.endsWith(":default"))
+    fail("Default accounts belong to the CLI itself; sign out there instead.");
+  const rec = deleteAccount(id);
+  if (!rec)
+    fail(`Unknown account: ${id}`);
+  if (rec.kind === "token")
+    await secretStore().delete(id);
+  console.log(`Removed ${id}.`);
+}
+async function cmdUpgrade(argv) {
+  const { values } = parseArgs({ args: argv, options: { check: { type: "boolean" }, yes: { type: "boolean", short: "y" } }, allowPositionals: true, strict: false });
+  const info = await checkForUpdate(true);
+  if (!info)
+    fail("Could not determine the latest release (GitHub/npm unreachable, or nothing published yet).");
+  if (!info.available) {
+    console.log(`just-usage v${VERSION} is up to date.`);
+    return;
+  }
+  console.log(`Update available: v${info.current} → v${info.latest}`);
+  if (values.check)
+    return;
+  const pm = detectPackageManager();
+  if (!values.yes && process.stdin.isTTY) {
+    const answer = await prompt(`Upgrade now with ${pm}? [Y/n] `);
+    if (answer && !/^y(es)?$/i.test(answer))
+      return;
+  }
+  const code = await runUpgrade(pm, info.latest);
+  if (code !== 0)
+    fail(`Upgrade command exited with ${code}.`);
+  console.log(`Upgraded to v${info.latest}.`);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const cmd = argv[0];
+  if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+    console.log(VERSION);
+    return;
+  }
+  if (cmd === "--help" || cmd === "-h" || cmd === "help") {
+    console.log(HELP);
+    return;
+  }
+  switch (cmd) {
+    case undefined:
+      return cmdServe([]);
+    case "serve":
+      return cmdServe(argv.slice(1));
+    case "status":
+      return cmdStatus(argv.slice(1));
+    case "accounts":
+      return cmdAccounts();
+    case "add":
+      return cmdAdd(argv.slice(1));
+    case "login":
+      return cmdLogin(argv.slice(1));
+    case "remove":
+    case "rm":
+      return cmdRemove(argv.slice(1));
+    case "upgrade":
+    case "update":
+      return cmdUpgrade(argv.slice(1));
+    default:
+      if (cmd.startsWith("-"))
+        return cmdServe(argv);
+      fail(`Unknown command: ${cmd}
+
+${HELP}`);
+  }
+}
+main().catch((e) => {
+  console.error(e instanceof Error ? e.message : String(e));
+  process.exit(1);
+});