quotacap 0.0.18 → 0.0.20

package/README.md

@@ -1,69 +1,63 @@
 # QuotaCap
 
-**Cross-harness AI quota dashboard + harness-callable advice.**
+QuotaCap helps you get more from the AI coding subscriptions you already pay for: Claude Code, Codex, Kimi Code, and Grok. It tracks one current usage window and reset time for each plan, then estimates which plan to use next from remaining usage and recent pace when available.
 
-One place to see how much of each AI subscription you've used. Shows when it resets and what to burn next. Goal is 100% use at reset.
+[![npm](https://img.shields.io/npm/v/quotacap)](https://www.npmjs.com/package/quotacap)
+[![CI](https://github.com/carlosboeing/quotacap/actions/workflows/test.yml/badge.svg)](https://github.com/carlosboeing/quotacap/actions)
+[![license](https://img.shields.io/github/license/carlosboeing/quotacap)](LICENSE)
+[![node](https://img.shields.io/node/v/quotacap)](package.json)
 
-Polls pluggable adapters (Claude, Codex, Gemini, Kimi, Grok, OpenCode). Stores history in SQLite. Serves:
+## Features
 
-* **Web dashboard** at `http://localhost:8787` — banner + 7-day strip + table with burn vs ideal. Includes stale badges and degraded banner.
-* **CLI** `quotacap` / `npx quotacap` — `status`, `advise --json`, `ingest`, `web`, `init`, `daemon`
-* **MCP server** — `get_quotas`, `get_recommendation`, `forecast` for any harness
+- **Visibility**: remaining usage and reset time for one current window per connected plan
+- **Pacing**: recent usage when history is available, or an estimated pace while QuotaCap collects it
+- **Advice**: an estimate of which plan to use next so you can use more of each allowance without exhausting one early
+- **Dashboard, CLI, and MCP**: the same data and advice on every surface
 
-Runs local-only by default. No prompts or file contents leave your machine.
+## Providers
+
+| Provider | Source |
+|---|---|
+| Claude Code | Live |
+| Codex | Live |
+| Kimi Code | Live |
+| Grok | Live |
+| Antigravity / Gemini | Manual (`quotacap ingest`) |
+
+Live adapters reuse the matching CLI login.
 
 ## Install
 
 ```bash
-# Binary — no Node needed (macOS + Linux, arm64/x64)
+# Binary: macOS and Linux, arm64 and x64. No Node.
 curl -fsSL https://raw.githubusercontent.com/carlosboeing/quotacap/main/install.sh | sh
 
-# Or via npm (requires Node 22.13+; node:sqlite needs --experimental-sqlite before 22.13)
-npm install -g quotacap   # global install
-npx quotacap              # run without install
+# Or install with npm (Node 22.13+)
+npm install -g quotacap
 ```
 
-The binary is a self-contained Bun-compiled executable from GitHub Releases.
-The npm package runs the same CLI on Node. Both put `quotacap` on your PATH.
+The binary is a self-contained executable from GitHub Releases.
+The npm package runs the same CLI on Node. To run without a global install, replace `quotacap` with `npx quotacap` in any command, for example `npx quotacap web`.
 
 ## Quick start
 
 ```bash
-quotacap init
-quotacap ingest --provider kimi --text "Current week: 22% used · resets Aug 29 at 11am"
-quotacap status --json
-quotacap web                          # http://localhost:8787
-quotacap advise --json                # tries HTTP, falls back to local DB
-quotacap advise --json --task heavy
-```
-
-## HTTP API
+# Terminal 1: leave this running
+quotacap init                 # writes ~/.quotacap/config.json
+quotacap web                  # dashboard at http://localhost:8787
 
-```bash
-curl http://localhost:8787/health
-curl http://localhost:8787/api/quotas
-curl "http://localhost:8787/api/recommendation?task=any"
-curl -X POST http://localhost:8787/api/refresh
+# Terminal 2: after the dashboard table fills
+quotacap status
+quotacap advise
 ```
 
-* `GET /health` → `{ok, uptime, lastPollAt}`
-* `GET /api/quotas` → `Quota[]` with `stale`, `ageMs`
-* `GET /api/recommendation?task=any` → `{use, reason, advisories}`
-* `POST /api/refresh` → `{fulfilled, rejected, lastPollAt, degraded}` — debounced 60s, always 200
-* `GET /` → `web/dist/index.html` if built, else `web/index.html`
+`web` stays in the foreground and starts the daemon.
 
-## CLI
+For a provider without a live adapter:
 
+```bash
+quotacap ingest --provider agy --text "65% used · resets Sep 1"
 ```
-quotacap status [--json]
-quotacap advise [--json] [--task any|heavy|light]
-quotacap ingest --provider <id> --text "..."
-quotacap web [--port 8787]
-quotacap daemon [--foreground]
-quotacap init
-```
-
-`advise` fetches `http://localhost:$port/api/recommendation` with 2s timeout. Falls back to local `recommend()` when daemon is down.
 
 ## MCP
 
@@ -76,44 +70,34 @@ quotacap init
 ```
 
 Use `"command": "npx", "args": ["quotacap", "mcp"]` when installed via npm only.
-Tools: `get_quotas`, `get_recommendation`, `forecast`. Wrapper over HTTP. Set `QUOTACAP_URL` to override.
 
-## How it works
+Tools: `get_quotas`, `get_recommendation`, `forecast`.
 
-```
-Adapters (claude-cli ✓, manual ✓, others → manual-paste)
-  → daemon (poll 15m + jitter, SQLite ~/.quotacap/quotacap.db)
-  → HTTP :8787
-  → dashboard + CLI + MCP (same handler)
-```
+## Privacy
 
-Adapters are isolated. One failure does not block others. Uses `Promise.allSettled` and per-adapter catch. `POST /api/refresh` always 200.
+Bound to `127.0.0.1`, with usage history stored under `~/.quotacap/`. Live adapters contact provider usage endpoints or invoke the provider CLI using your existing login. Codex, Kimi, and Grok adapters may refresh expired OAuth tokens and update the CLI-owned credential file. QuotaCap stores no API keys.
 
-## Config
+## Docs
 
-`~/.quotacap/config.json`:
+- [Architecture](docs/architecture.md)
+- [Changelog](docs/CHANGELOG.md)
+- [Roadmap](docs/ROADMAP.md)
 
-```json
-{ "port": 8787, "pollMinutes": 15, "enabledProviders": ["claude"] }
-```
+## License
 
-DB is `~/.quotacap/quotacap.db` (`quotas`, `snapshots`).
+MIT. See [LICENSE](LICENSE).
 
-## Development
+<details>
+<summary>Development</summary>
 
 ```bash
-npm test              # vitest run (10 files) — builds first via pretest
+npm test              # vitest (builds first via pretest)
 bun test tests/bun/   # bun-runtime tests (sqlite adapter, MCP translation)
-npm run build         # vite build → embed web assets → tsc → flatten dist → chmod bin
-npm run build:bin     # bun build --compile (current platform, or pass targets)
-npx tsc --noEmit
+npm run build
+npm run build:bin
 ```
 
-The `store/db.ts` adapter picks `node:sqlite` on Node and `bun:sqlite` on Bun, so
-the same code runs as an npm package and as a compiled binary.
-
-See `.workbench/2-design/2026-08-28-quotacap-design.md` for spec. See `docs/ROADMAP.md` for next steps.
-
-## License
+The store uses `node:sqlite` on Node and `bun:sqlite` on Bun.
+The same code is an npm package and a compiled binary.
 
-MIT — see [LICENSE](LICENSE).
+</details>

package/dist/adapters/codex.d.ts

@@ -0,0 +1,7 @@
+import type { Quota } from "./types.js";
+export declare function parseCodexUsage(body: any, now?: Date): Quota;
+export declare const codexAdapter: {
+    id: string;
+    requiresAuth: string;
+    poll(): Promise<Quota>;
+};

package/dist/adapters/codex.js

@@ -0,0 +1,61 @@
+import os from "node:os";
+import path from "node:path";
+import { readJsonFile, getJson, postForm, persistCreds } from "./core.js";
+export function parseCodexUsage(body, now = new Date()) {
+    const rl = body?.rate_limit ?? {};
+    const win = rl.secondary_window ?? rl.primary_window;
+    if (!win)
+        throw new Error("codex: no rate-limit window in response");
+    const resetsAt = new Date(win.reset_at * 1000).toISOString();
+    const periodStart = new Date((win.reset_at - win.limit_window_seconds) * 1000).toISOString();
+    return {
+        provider: "codex",
+        plan: body.plan_type ?? "unknown",
+        usedPct: win.used_percent ?? 0,
+        resetsAt,
+        periodStart,
+        raw: JSON.stringify(body),
+        source: "api",
+        fetchedAt: now.toISOString(),
+    };
+}
+const USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const REFRESH_URL = "https://auth.openai.com/oauth/token";
+const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+function codexHome() {
+    return process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
+}
+export const codexAdapter = {
+    id: "codex",
+    requiresAuth: "~/.codex/auth.json (codex login)",
+    async poll() {
+        const authFile = path.join(codexHome(), "auth.json");
+        const auth = await readJsonFile(authFile);
+        const at = auth.tokens?.access_token;
+        if (!at)
+            throw new Error("codex: no access_token in auth.json — run codex login");
+        const headers = { Authorization: `Bearer ${at}`, "User-Agent": "quotacap" };
+        if (auth.tokens?.account_id)
+            headers["ChatGPT-Account-Id"] = auth.tokens.account_id;
+        try {
+            return parseCodexUsage(await getJson(USAGE_URL, headers));
+        }
+        catch (e) {
+            if (e.status !== 401)
+                throw e;
+            const rf = auth.tokens?.refresh_token;
+            if (!rf)
+                throw e;
+            const tok = await postForm(REFRESH_URL, { grant_type: "refresh_token", client_id: CLIENT_ID, refresh_token: rf });
+            await persistCreds(authFile, (cur) => {
+                const tokens = { ...(cur.tokens ?? {}), };
+                if (tok.access_token)
+                    tokens.access_token = tok.access_token;
+                if (tok.refresh_token)
+                    tokens.refresh_token = tok.refresh_token;
+                return { ...cur, tokens, last_refresh: new Date().toISOString() };
+            });
+            return parseCodexUsage(await getJson(USAGE_URL, { ...headers, Authorization: `Bearer ${tok.access_token}` }));
+        }
+    },
+};

package/dist/adapters/core.d.ts

@@ -0,0 +1,9 @@
+export declare class HttpError extends Error {
+    status: number;
+    body: string;
+    constructor(status: number, body: string);
+}
+export declare function readJsonFile<T>(file: string): Promise<T>;
+export declare function postForm(url: string, fields: Record<string, string>, extraHeaders?: Record<string, string>, timeoutMs?: number): Promise<any>;
+export declare function getJson(url: string, headers: Record<string, string>, timeoutMs?: number): Promise<any>;
+export declare function persistCreds<T>(file: string, update: (cur: T) => T, backupSuffix?: string): Promise<boolean>;

package/dist/adapters/core.js

@@ -0,0 +1,90 @@
+import fs from "node:fs/promises";
+export class HttpError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        super(`HTTP ${status}: ${String(body).slice(0, 120)}`);
+        this.status = status;
+        this.body = body;
+    }
+}
+export async function readJsonFile(file) {
+    const raw = await fs.readFile(file, "utf8");
+    return JSON.parse(raw);
+}
+async function parseResponse(res) {
+    const text = await res.text();
+    if (!res.ok)
+        throw new HttpError(res.status, text);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+export async function postForm(url, fields, extraHeaders = {}, timeoutMs = 8000) {
+    const res = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded", ...extraHeaders },
+        body: new URLSearchParams(fields).toString(),
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    return parseResponse(res);
+}
+export async function getJson(url, headers, timeoutMs = 8000) {
+    const res = await fetch(url, { headers, signal: AbortSignal.timeout(timeoutMs) });
+    return parseResponse(res);
+}
+async function acquireLock(lockPath, timeoutMs = 2000) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        try {
+            const fh = await fs.open(lockPath, "wx");
+            await fh.close();
+            return;
+        }
+        catch (e) {
+            if (e.code !== "EEXIST")
+                throw e;
+            try {
+                const st = await fs.stat(lockPath);
+                if (Date.now() - st.mtimeMs > 5000) {
+                    await fs.rm(lockPath, { force: true });
+                    continue;
+                }
+            }
+            catch {
+                /* lock vanished between open and stat — retry */
+            }
+            if (Date.now() > deadline)
+                throw new Error(`persistCreds: lock busy: ${lockPath}`);
+            await new Promise((r) => setTimeout(r, 25));
+        }
+    }
+}
+export async function persistCreds(file, update, backupSuffix = ".qc-bak") {
+    const lock = file + ".qc-lock";
+    await acquireLock(lock);
+    try {
+        const cur = await readJsonFile(file);
+        const next = update(cur);
+        const bak = file + backupSuffix;
+        let first = false;
+        try {
+            await fs.access(bak);
+        }
+        catch {
+            await fs.copyFile(file, bak);
+            first = true;
+        }
+        const st = await fs.stat(file);
+        const tmp = `${file}.qc-tmp-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+        await fs.writeFile(tmp, JSON.stringify(next, null, 2), { mode: st.mode & 0o777 });
+        await fs.rename(tmp, file);
+        return first;
+    }
+    finally {
+        await fs.rm(lock, { force: true });
+    }
+}

package/dist/adapters/grok.d.ts

@@ -0,0 +1,7 @@
+import type { Quota } from "./types.js";
+export declare function parseGrokUsage(body: any, now?: Date): Quota;
+export declare const grokAdapter: {
+    id: string;
+    requiresAuth: string;
+    poll(): Promise<Quota>;
+};

package/dist/adapters/grok.js

@@ -0,0 +1,82 @@
+import os from "node:os";
+import path from "node:path";
+import { readJsonFile, getJson, postForm, persistCreds } from "./core.js";
+const BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+const REFRESH_URL = "https://auth.x.ai/oauth2/token";
+const CLIENT_VERSION = "1.0.0";
+export function parseGrokUsage(body, now = new Date()) {
+    const cfg = body?.config;
+    if (!cfg)
+        throw new Error("grok: no config in billing response");
+    const pct = cfg.creditUsagePercent;
+    if (typeof pct !== "number")
+        throw new Error("grok: creditUsagePercent missing");
+    const period = cfg.currentPeriod ?? {};
+    return {
+        provider: "grok",
+        plan: body?.subscriptionTier ?? "unknown",
+        usedPct: pct,
+        resetsAt: period.end ?? new Date(now.getTime() + 7 * 86400000).toISOString(),
+        periodStart: period.start ?? new Date(now.getTime() - 7 * 86400000).toISOString(),
+        raw: JSON.stringify(body),
+        source: "api",
+        fetchedAt: now.toISOString(),
+    };
+}
+function grokHome() {
+    return process.env.GROK_HOME ?? path.join(os.homedir(), ".grok");
+}
+async function loadEntry() {
+    const file = path.join(grokHome(), "auth.json");
+    const auth = await readJsonFile(file);
+    for (const [entryKey, entry] of Object.entries(auth)) {
+        if (entry.refresh_token)
+            return { file, entryKey, entry };
+    }
+    throw new Error("grok: no refresh_token in auth.json — run `grok login`");
+}
+export const grokAdapter = {
+    id: "grok",
+    requiresAuth: "~/.grok/auth.json (grok login)",
+    async poll() {
+        const { file, entryKey, entry } = await loadEntry();
+        const expiryMs = entry.expires_at ? Date.parse(String(entry.expires_at)) : NaN;
+        const reuseToken = Boolean(entry.key) && Number.isFinite(expiryMs) && expiryMs - 60000 > Date.now();
+        let token;
+        if (reuseToken) {
+            token = entry.key;
+        }
+        else {
+            const tok = await postForm(REFRESH_URL, {
+                grant_type: "refresh_token",
+                client_id: entry.oidc_client_id ?? "",
+                refresh_token: entry.refresh_token ?? "",
+            });
+            if (!tok.access_token)
+                throw new Error("grok: refresh returned no access_token");
+            await persistCreds(file, (cur) => {
+                const next = { ...cur };
+                const target = next[entryKey];
+                if (target) {
+                    next[entryKey] = {
+                        ...target,
+                        key: tok.access_token ?? target.key,
+                        refresh_token: tok.refresh_token ?? target.refresh_token,
+                        expires_at: tok.expires_at ??
+                            (tok.expires_in ? new Date(Date.now() + Number(tok.expires_in) * 1000).toISOString() : target.expires_at),
+                    };
+                }
+                return next;
+            });
+            token = String(tok.access_token);
+        }
+        const body = await getJson(BILLING_URL, {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/json",
+            "x-grok-client-version": CLIENT_VERSION,
+            "x-grok-client-surface": "grok-build",
+            "X-XAI-Token-Auth": "xai-grok-cli",
+        });
+        return parseGrokUsage(body);
+    },
+};

package/dist/adapters/index.js

@@ -1,8 +1,14 @@
 import { claudeAdapter } from "./claude.js";
 import { manualAdapter } from "./manual.js";
+import { codexAdapter } from "./codex.js";
+import { kimiAdapter } from "./kimi.js";
+import { grokAdapter } from "./grok.js";
 export const adapters = {
     claude: claudeAdapter,
     manual: manualAdapter,
+    codex: codexAdapter,
+    kimi: kimiAdapter,
+    grok: grokAdapter,
 };
 function withTimeout(p, ms) {
     return new Promise((resolve, reject) => {

package/dist/adapters/kimi.d.ts

@@ -0,0 +1,7 @@
+import type { Quota } from "./types.js";
+export declare function parseKimiUsage(body: any, now?: Date): Quota;
+export declare const kimiAdapter: {
+    id: string;
+    requiresAuth: string;
+    poll(): Promise<Quota>;
+};

package/dist/adapters/kimi.js

@@ -0,0 +1,98 @@
+import os from "node:os";
+import path from "node:path";
+import { readJsonFile, getJson, postForm, persistCreds } from "./core.js";
+const USAGE_URL = "https://api.kimi.com/coding/v1/usages";
+const REFRESH_URL = "https://auth.kimi.com/api/oauth/token";
+const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
+export function parseKimiUsage(body, now = new Date()) {
+    const usage = body?.usage;
+    if (!usage)
+        throw new Error("kimi: no usage in response");
+    const limit = Number(usage.limit);
+    const used = Number(usage.used);
+    if (!(limit > 0) || Number.isNaN(used))
+        throw new Error("kimi: bad usage numbers");
+    const resetsAt = usage.resetTime;
+    if (Number.isNaN(new Date(resetsAt).getTime()))
+        throw new Error("kimi: bad resetTime");
+    const periodStart = new Date(new Date(resetsAt).getTime() - 7 * 86400000).toISOString();
+    const level = body?.user?.membership?.level;
+    return {
+        provider: "kimi",
+        plan: level ? String(level).replace(/^LEVEL_/, "").toLowerCase() : "unknown",
+        usedPct: Math.round((used / limit) * 100),
+        resetsAt,
+        periodStart,
+        raw: JSON.stringify(body),
+        source: "api",
+        fetchedAt: now.toISOString(),
+    };
+}
+function credsCandidates() {
+    const home = process.env.KIMI_CODE_HOME ?? path.join(os.homedir(), ".kimi-code");
+    const legacy = path.join(os.homedir(), ".kimi", "credentials", "kimi-code.json");
+    return [path.join(home, "credentials", "kimi-code.json"), legacy];
+}
+async function loadCreds() {
+    for (const file of credsCandidates()) {
+        try {
+            return { file, creds: await readJsonFile(file) };
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error("kimi: no credentials file — run `kimi login`");
+}
+function isFreshExpiry(raw) {
+    const v = Number(raw);
+    if (!Number.isFinite(v) || v <= 0)
+        return false;
+    const ms = v < 1e12 ? v * 1000 : v; // CLI stores seconds; legacy rows from earlier quotas are ms
+    return ms > Date.now();
+}
+async function refreshAndPersist(file, creds) {
+    if (!creds.refresh_token)
+        throw new Error("kimi: no refresh_token — run `kimi login`");
+    const tok = await postForm(REFRESH_URL, {
+        grant_type: "refresh_token",
+        client_id: CLIENT_ID,
+        refresh_token: creds.refresh_token,
+    });
+    if (!tok.access_token)
+        throw new Error("kimi: refresh returned no access_token");
+    await persistCreds(file, (cur) => ({
+        ...cur,
+        access_token: tok.access_token,
+        refresh_token: tok.refresh_token ?? cur.refresh_token,
+        expires_at: Math.floor(Date.now() / 1000) + (Number(tok.expires_in) || 3600),
+        token_type: tok.token_type ?? cur.token_type,
+        scope: tok.scope ?? cur.scope,
+    }));
+    return String(tok.access_token);
+}
+export const kimiAdapter = {
+    id: "kimi",
+    requiresAuth: "~/.kimi-code/credentials/kimi-code.json (kimi login)",
+    async poll() {
+        const { file, creds } = await loadCreds();
+        let token = creds.access_token ?? "";
+        let justRefreshed = false;
+        if (!token)
+            throw new Error("kimi: no access_token — run `kimi login`");
+        if (!isFreshExpiry(creds.expires_at)) {
+            token = await refreshAndPersist(file, creds);
+            justRefreshed = true;
+        }
+        const call = (t) => getJson(USAGE_URL, { Authorization: `Bearer ${t}` }).then(parseKimiUsage);
+        try {
+            return await call(token);
+        }
+        catch (e) {
+            if (e.status !== 401 || justRefreshed)
+                throw e;
+            const fresh = await refreshAndPersist(file, creds);
+            return await call(fresh);
+        }
+    },
+};

package/dist/config.js

@@ -15,7 +15,7 @@ export function getDbPath(p) {
 const ConfigSchema = z.object({
     port: z.number().default(8787),
     pollMinutes: z.number().default(15),
-    enabledProviders: z.array(z.string()).default(["claude"]),
+    enabledProviders: z.array(z.string()).default(["claude", "codex", "kimi", "grok"]),
 });
 export async function readConfig(p) {
     try {

package/dist/src/adapters/codex.d.ts

@@ -0,0 +1,7 @@
+import type { Quota } from "./types.js";
+export declare function parseCodexUsage(body: any, now?: Date): Quota;
+export declare const codexAdapter: {
+    id: string;
+    requiresAuth: string;
+    poll(): Promise<Quota>;
+};

package/dist/src/adapters/codex.js

@@ -0,0 +1,61 @@
+import os from "node:os";
+import path from "node:path";
+import { readJsonFile, getJson, postForm, persistCreds } from "./core.js";
+export function parseCodexUsage(body, now = new Date()) {
+    const rl = body?.rate_limit ?? {};
+    const win = rl.secondary_window ?? rl.primary_window;
+    if (!win)
+        throw new Error("codex: no rate-limit window in response");
+    const resetsAt = new Date(win.reset_at * 1000).toISOString();
+    const periodStart = new Date((win.reset_at - win.limit_window_seconds) * 1000).toISOString();
+    return {
+        provider: "codex",
+        plan: body.plan_type ?? "unknown",
+        usedPct: win.used_percent ?? 0,
+        resetsAt,
+        periodStart,
+        raw: JSON.stringify(body),
+        source: "api",
+        fetchedAt: now.toISOString(),
+    };
+}
+const USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const REFRESH_URL = "https://auth.openai.com/oauth/token";
+const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+function codexHome() {
+    return process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
+}
+export const codexAdapter = {
+    id: "codex",
+    requiresAuth: "~/.codex/auth.json (codex login)",
+    async poll() {
+        const authFile = path.join(codexHome(), "auth.json");
+        const auth = await readJsonFile(authFile);
+        const at = auth.tokens?.access_token;
+        if (!at)
+            throw new Error("codex: no access_token in auth.json — run codex login");
+        const headers = { Authorization: `Bearer ${at}`, "User-Agent": "quotacap" };
+        if (auth.tokens?.account_id)
+            headers["ChatGPT-Account-Id"] = auth.tokens.account_id;
+        try {
+            return parseCodexUsage(await getJson(USAGE_URL, headers));
+        }
+        catch (e) {
+            if (e.status !== 401)
+                throw e;
+            const rf = auth.tokens?.refresh_token;
+            if (!rf)
+                throw e;
+            const tok = await postForm(REFRESH_URL, { grant_type: "refresh_token", client_id: CLIENT_ID, refresh_token: rf });
+            await persistCreds(authFile, (cur) => {
+                const tokens = { ...(cur.tokens ?? {}), };
+                if (tok.access_token)
+                    tokens.access_token = tok.access_token;
+                if (tok.refresh_token)
+                    tokens.refresh_token = tok.refresh_token;
+                return { ...cur, tokens, last_refresh: new Date().toISOString() };
+            });
+            return parseCodexUsage(await getJson(USAGE_URL, { ...headers, Authorization: `Bearer ${tok.access_token}` }));
+        }
+    },
+};

package/dist/src/adapters/core.d.ts

@@ -0,0 +1,9 @@
+export declare class HttpError extends Error {
+    status: number;
+    body: string;
+    constructor(status: number, body: string);
+}
+export declare function readJsonFile<T>(file: string): Promise<T>;
+export declare function postForm(url: string, fields: Record<string, string>, extraHeaders?: Record<string, string>, timeoutMs?: number): Promise<any>;
+export declare function getJson(url: string, headers: Record<string, string>, timeoutMs?: number): Promise<any>;
+export declare function persistCreds<T>(file: string, update: (cur: T) => T, backupSuffix?: string): Promise<boolean>;