quotacap 0.0.20 → 0.0.23

package/dist/adapters/grok.js

@@ -1,82 +1,126 @@
 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 ?? {};
+import { runPty, stripAnsi } from "./pty.js";
+import { adapterSignal } from "../runtime/spawn.js";
+const FULL_MONTHS = {
+    january: 0, february: 1, march: 2, april: 3, may: 4, june: 5,
+    july: 6, august: 7, september: 8, october: 9, november: 10, december: 11,
+};
+const ABBR_MONTHS = {
+    jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5,
+    jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11,
+};
+function parseGrokReset(raw, now) {
+    const m = raw.trim().match(/^([A-Za-z]+)\s+(\d{1,2}),\s*(\d{1,2}):(\d{2})$/);
+    if (!m)
+        return null;
+    const monStr = m[1].toLowerCase();
+    const day = parseInt(m[2], 10);
+    const hours = parseInt(m[3], 10);
+    const mins = parseInt(m[4], 10);
+    let month = FULL_MONTHS[monStr];
+    if (month === undefined)
+        month = ABBR_MONTHS[monStr.slice(0, 3)];
+    if (month === undefined || !Number.isFinite(day) || !Number.isFinite(hours) || !Number.isFinite(mins))
+        return null;
+    if (day < 1 || day > 31 || hours < 0 || hours > 23 || mins < 0 || mins > 59)
+        return null;
+    let year = now.getFullYear();
+    let dt = new Date(year, month, day, hours, mins, 0, 0);
+    if (Number.isNaN(dt.getTime()))
+        return null;
+    if (dt.getTime() < now.getTime()) {
+        dt = new Date(year + 1, month, day, hours, mins, 0, 0);
+        if (Number.isNaN(dt.getTime()))
+            return null;
+    }
+    return dt.toISOString();
+}
+export function parseGrokTui(text, now = new Date()) {
+    const cleaned = stripAnsi(text);
+    const planMatch = cleaned.match(/Weekly lim[i!l]t\s*\(([^)]+)\)/i);
+    let plan = "unknown";
+    if (planMatch) {
+        plan = planMatch[1].trim();
+    }
+    else {
+        const tier = cleaned.match(/\b(SuperGrok|Grok\s+Pro|Grok\s+Enterprise|Grok\s+Basic)\b/i);
+        if (tier)
+            plan = tier[1].trim();
+    }
+    const pctRe = /Weekly lim[i!l]t[^\n%]*?(\d+)%/i;
+    const mPct = cleaned.match(pctRe);
+    let usedPct = null;
+    if (mPct) {
+        const v = parseInt(mPct[1], 10);
+        if (Number.isFinite(v) && v >= 0 && v <= 100)
+            usedPct = v;
+    }
+    if (usedPct === null) {
+        const barRe = /[█░▓▓]+\s*(\d+)%/;
+        const b = cleaned.match(barRe);
+        if (b) {
+            const v = parseInt(b[1], 10);
+            if (Number.isFinite(v) && v >= 0 && v <= 100)
+                usedPct = v;
+        }
+    }
+    if (usedPct === null)
+        throw new Error("grok: weekly percent not found in TUI output");
+    let creditsUsd;
+    const mCred = cleaned.match(/Credits:\s*\$([0-9]+(?:\.[0-9]+)?)/i);
+    if (mCred) {
+        const v = parseFloat(mCred[1]);
+        if (Number.isFinite(v) && v >= 0)
+            creditsUsd = v;
+    }
+    const mReset = cleaned.match(/Resets:\s*([A-Za-z]+\s+\d+,\s*\d+:\d+)/i);
+    let resetsAt = null;
+    let estimated = false;
+    if (mReset) {
+        const resetsRaw = mReset[1].trim();
+        resetsAt = parseGrokReset(resetsRaw, now);
+        if (!resetsAt)
+            throw new Error(`grok: bad resets timestamp "${resetsRaw}"`);
+    }
+    else if (cleaned.match(/Resets:/i)) {
+        throw new Error("grok: bad resets timestamp");
+    }
+    else {
+        resetsAt = new Date(now.getTime() + 7 * 86400000).toISOString();
+        estimated = true;
+    }
+    const periodStart = new Date(new Date(resetsAt).getTime() - 7 * 86400000).toISOString();
     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",
+        plan,
+        usedPct,
+        resetsAt,
+        periodStart,
+        source: "tui",
         fetchedAt: now.toISOString(),
+        creditsUsd,
+        resetsAtEstimated: estimated || undefined,
+        raw: cleaned.slice(0, 4096),
     };
 }
-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)",
+    requiresAuth: "grok login (CLI owns credentials)",
     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",
+        const transcript = await runPty({
+            file: "grok",
+            args: [],
+            cwd: os.homedir(),
+            cols: 140,
+            rows: 50,
+            settleDelayMs: 5000,
+            input: "/usage\r",
+            completionRegex: /Weekly lim|Credits:/i,
+            timeoutMs: 14000,
+            maxBytes: 256 * 1024,
+            signal: adapterSignal("grok"),
+            label: "grok",
         });
-        return parseGrokUsage(body);
+        return parseGrokTui(transcript);
     },
 };

package/dist/adapters/index.d.ts

@@ -1,9 +1,12 @@
 import type { Adapter } from "./types.js";
 export declare const adapters: Record<string, Adapter>;
-export declare function pollAll(enabled: string[]): Promise<({
+export interface PollAllOptions {
+    timeouts?: Record<string, number>;
+}
+export declare function pollAll(enabled: string[], opts?: PollAllOptions): Promise<({
     provider: string;
     status: "fulfilled";
-    value: import("./types.js").Quota;
+    value: unknown;
     reason?: undefined;
 } | {
     provider: string;

package/dist/adapters/index.js

@@ -3,28 +3,55 @@ import { manualAdapter } from "./manual.js";
 import { codexAdapter } from "./codex.js";
 import { kimiAdapter } from "./kimi.js";
 import { grokAdapter } from "./grok.js";
+import { agyAdapter } from "./agy.js";
+import { installAdapterSignal, clearAdapterSignal } from "../runtime/spawn.js";
 export const adapters = {
     claude: claudeAdapter,
     manual: manualAdapter,
     codex: codexAdapter,
     kimi: kimiAdapter,
     grok: grokAdapter,
+    agy: agyAdapter,
 };
-function withTimeout(p, ms) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms);
-        Promise.resolve(p).then((v) => { clearTimeout(timer); resolve(v); }, (e) => { clearTimeout(timer); reject(e); });
-    });
-}
-export async function pollAll(enabled) {
+const ADAPTER_TIMEOUTS = {
+    claude: 8000,
+    codex: 12000,
+    kimi: 8000,
+    grok: 14000,
+    agy: 20000,
+};
+export async function pollAll(enabled, opts) {
     const rawJobs = enabled.map(id => {
         const a = adapters[id];
         if (!a)
             return Promise.reject(new Error(`unknown adapter ${id}`));
         // manual adapter has no poll capability — skip without degraded
         if (id === "manual")
-            return Promise.reject(new Error("manual skipped — use ingest"));
-        return withTimeout(a.poll(), 8000);
+            return Promise.reject(new Error("manual skipped"));
+        const timeout = opts?.timeouts?.[id] ?? ADAPTER_TIMEOUTS[id] ?? 8000;
+        // One controller per adapter: a timeout aborts only that adapter's
+        // children; the signal clears when its job settles.
+        const controller = new AbortController();
+        installAdapterSignal(id, controller.signal);
+        let p;
+        try {
+            p = Promise.resolve(a.poll());
+        }
+        catch (e) {
+            clearAdapterSignal(id);
+            throw e;
+        }
+        const gated = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                try {
+                    controller.abort();
+                }
+                catch { }
+                reject(new Error(`timeout after ${timeout}ms`));
+            }, timeout);
+            p.then((v) => { clearTimeout(timer); resolve(v); }, (e) => { clearTimeout(timer); reject(e); });
+        });
+        return gated.finally(() => clearAdapterSignal(id));
     });
     const settled = await Promise.allSettled(rawJobs);
     return settled.map((s, i) => {

package/dist/adapters/kimi.d.ts

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

package/dist/adapters/kimi.js

@@ -1,98 +1,76 @@
 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;
+import { parseResetText } from "./parse.js";
+import { runPty, stripAnsi } from "./pty.js";
+import { adapterSignal } from "../runtime/spawn.js";
+export function parseKimiTui(text, now = new Date()) {
+    const cleaned = stripAnsi(text);
+    const weeklyRe = /Weekly limit\s+[^0-9]*(\d+)%\s+used\s+resets\s+(in\s+[^\n│\r]+)/i;
+    const fiveRe = /5h limit\s+[^0-9]*(\d+)%\s+used\s+resets\s+(in\s+[^\n│\r]+)/i;
+    const w = cleaned.match(weeklyRe);
+    if (!w)
+        throw new Error("kimi: weekly limit not found in TUI output");
+    const f = cleaned.match(fiveRe);
+    if (!f)
+        throw new Error("kimi: 5h limit not found in TUI output");
+    const usedPct = parseInt(w[1], 10);
+    const sessionPct = parseInt(f[1], 10);
+    if (!Number.isFinite(usedPct) || usedPct < 0 || usedPct > 100)
+        throw new Error("kimi: bad weekly pct");
+    if (!Number.isFinite(sessionPct) || sessionPct < 0 || sessionPct > 100)
+        throw new Error("kimi: bad 5h pct");
+    const weeklyRaw = w[2].trim();
+    const fiveRaw = f[2].trim();
+    const weeklyIso = parseResetText(`resets ${weeklyRaw}`, now);
+    if (!weeklyIso)
+        throw new Error(`kimi: bad weekly reset "${weeklyRaw}"`);
+    const fiveIso = parseResetText(`resets ${fiveRaw}`, now);
+    if (!fiveIso)
+        throw new Error(`kimi: bad 5h reset "${fiveRaw}"`);
+    let plan = "unknown";
+    const paren = cleaned.match(/Weekly limit\s*\(([^)]+)\)/i);
+    if (paren) {
+        plan = paren[1].trim().toLowerCase();
+    }
+    else {
+        const lvl = cleaned.match(/level\s*[:\-]\s*([A-Za-z0-9_\-]+)/i);
+        if (lvl)
+            plan = lvl[1].trim().toLowerCase().replace(/^level_/i, "");
+    }
+    const periodStart = new Date(new Date(weeklyIso).getTime() - 7 * 86400000).toISOString();
     return {
         provider: "kimi",
-        plan: level ? String(level).replace(/^LEVEL_/, "").toLowerCase() : "unknown",
-        usedPct: Math.round((used / limit) * 100),
-        resetsAt,
+        plan,
+        usedPct,
+        sessionPct,
+        resetsAt: weeklyIso,
         periodStart,
-        raw: JSON.stringify(body),
-        source: "api",
+        source: "tui",
         fetchedAt: now.toISOString(),
+        raw: cleaned.slice(0, 4096),
     };
 }
-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)",
+    requiresAuth: "kimi login (CLI owns credentials)",
     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);
-        }
+        // Use homedir as neutral cwd so quota modal does not depend on project path
+        // and workspace-trust prompts are minimized. Fail closed if trust prompt appears.
+        const transcript = await runPty({
+            file: "kimi",
+            args: [],
+            cols: 140,
+            rows: 35,
+            cwd: os.homedir(),
+            readyRegex: /Welcome to Kimi Code|context:/i,
+            readyTimeoutMs: 8000,
+            input: "/usage\r",
+            completionRegex: /Weekly limit[\s\S]*?5h limit|5h limit[\s\S]*?Weekly limit/i,
+            abortOn: /Trust this folder\?/i,
+            timeoutMs: 8000,
+            maxBytes: 256 * 1024,
+            signal: adapterSignal("kimi"),
+            label: "kimi",
+        });
+        return parseKimiTui(transcript);
     },
 };

package/dist/adapters/manual.d.ts

@@ -1,8 +1,8 @@
-import type { Quota } from "./types.js";
-export declare function parseManualUsage(provider: string, text: string, now?: Date): Quota;
+import type { ParsedQuota } from "./types.js";
+export declare function parseManualUsage(provider: string, text: string, now?: Date): ParsedQuota;
 export declare const manualAdapter: {
     id: string;
     requiresAuth: string;
-    ingest(provider: string, text: string): Promise<Quota>;
-    poll(): Promise<Quota>;
+    ingest(provider: string, text: string): Promise<ParsedQuota>;
+    poll(): Promise<ParsedQuota>;
 };

package/dist/adapters/manual.js

@@ -11,9 +11,9 @@ export function parseManualUsage(provider, text, now = new Date()) {
         usedPct,
         resetsAt,
         periodStart,
-        raw: text,
         source: "manual",
         fetchedAt: now.toISOString(),
+        raw: text,
     };
 }
 export const manualAdapter = {
@@ -23,6 +23,6 @@ export const manualAdapter = {
         return parseManualUsage(provider, text);
     },
     async poll() {
-        throw new Error("manual has no poll — use ingest");
+        throw new Error("manual has no poll");
     },
 };

package/dist/adapters/pty.d.ts

@@ -0,0 +1,41 @@
+export declare function stripAnsi(s: string): string;
+export interface PtyRunOptions {
+    file: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+    readyRegex?: RegExp;
+    readyTimeoutMs?: number;
+    settleDelayMs?: number;
+    input: string;
+    completionRegex?: RegExp;
+    /** If matched, abort immediately with a clear error (e.g. trust prompts). */
+    abortOn?: RegExp;
+    timeoutMs: number;
+    maxBytes?: number;
+    /** Abort kills the child via the existing kill path and rejects `pty aborted`. */
+    signal?: AbortSignal;
+    /** Diagnostic label for the tracked child (adapter id). */
+    label?: string;
+}
+export interface SpawnHelperRepair {
+    helper: string;
+    ok: boolean;
+    error?: string;
+}
+/**
+ * Lazy replacement for the removed postinstall: best-effort `chmod 0o755`
+ * over every prebuilds entry `spawn-helper` under the given node-pty roots.
+ * Missing roots, missing prebuild dirs, and missing helpers are skipped
+ * silently; only attempted repairs are recorded.
+ */
+export declare function repairSpawnHelpers(roots: string[], chmod?: (p: string, mode: number) => void): SpawnHelperRepair[];
+/**
+ * Human diagnostic for failed repairs, or null when nothing failed.
+ * Load-bearing for root-owned trees (e.g. `sudo` global installs) where the
+ * invoking user cannot repair: without it the failure would go opaque again.
+ */
+export declare function describeSpawnHelperRepairs(outcomes: SpawnHelperRepair[]): string | null;
+export declare function runPty(opts: PtyRunOptions): Promise<string>;