quotacap 0.0.17 → 0.0.19

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/format/table.js

@@ -28,15 +28,15 @@ export function renderQuotasTable(quotas, advisories = []) {
                     : null;
             if (!rate)
                 return "—";
-            // Pace glyphs are single-width text-presentation (no VS16), so they
-            // cannot shift pipes in renderers that miscount emoji width.
+            // Verdict against the ideal rate: outside the +-20% band the cell says
+            // (fast)/(slow); inside it a single-width check mark.
             const value = a?.burnMeasured ? a.burnRate : q.periodStart ? (q.usedPct ?? 0) / Math.max(0.1, (Date.now() - new Date(q.periodStart).getTime()) / 86400000) : null;
             const ideal = a?.idealRate;
             if (ideal != null && value != null) {
-                if (value > ideal)
-                    return `${rate} ⚠`;
+                if (value > ideal * 1.2)
+                    return `${rate} (fast)`;
                 if (value < ideal * 0.8)
-                    return `${rate} ↓`;
+                    return `${rate} (slow)`;
                 return `${rate} ✔`;
             }
             return rate;

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>;

package/dist/src/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/src/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>;
+};