@juanbenjumea/pi-provider-usage-fetcher 0.0.0-stage → 0.3.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Juan Benjumea
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,89 @@
-# Temporary Holding Version
+# @juanbenjumea/pi-provider-usage-fetcher
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Shared **provider usage** library for Pi extensions, agentq, and other tooling.
+
+Despite the name (historical), this package covers more than OpenCode Go:
+
+| Provider | Auth | Source |
+|---|---|---|
+| **OpenCode Go** | API key (same as chat) | `GET https://opencode.ai/zen/go/v1/usage` |
+| **Claude** | macOS keychain, `auth.json`, explicit apiKey | `GET https://api.anthropic.com/api/oauth/usage` |
+| **Codex** | `auth.json`, `~/.codex/auth.json`, explicit apiKey | `GET https://chatgpt.com/backend-api/wham/usage` |
+| **ClinePass** | `CLINE_API_KEY`, `auth.json`, explicit apiKey | `api.cline.bot/api/v1/*` |
+| **Umans** | `UMANS_API_KEY`, `auth.json`, explicit apiKey | `GET https://api.code.umans.ai/v1/usage` |
+| **Copilot** | `auth.json` (`github-copilot`), explicit apiKey | `GET https://api.github.com/copilot_internal/user` |
+| **Gemini** | `auth.json`, `~/.gemini/oauth_creds.json`, explicit apiKey | `POST https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota` |
+| **Kimi Coding** | `KIMI_API_KEY`, `auth.json`, explicit apiKey | `GET https://api.kimi.com/coding/v1/usages` |
+| **Synthetic** | `SYNTHETIC_API_KEY`, `auth.json`, explicit apiKey | `GET https://api.synthetic.new/v2/quotas` |
+| **z.ai / GLM** | Region-specific environment key, `auth.json`, explicit apiKey | `GET {api.z.ai or open.bigmodel.cn}/api/monitor/usage/quota/limit` |
+| **Cursor** | `quota-sessions.json`, env, CodexBar, Cursor app DB | `cursor.com/api/usage-summary` |
+| **CommandCode** | `quota-sessions.json`, env, CodexBar | `api.commandcode.ai/internal/billing/*` |
+| **Openference** | API key from caller, `OPENFERENCE_API_KEY`, or `auth.json` | `GET https://openference.com/api/user/me` |
+
+Legacy OpenCode Go dashboard cookie scraping remains as a fallback when no API key is configured.
+
+## Install
+
+```bash
+npm install @juanbenjumea/pi-provider-usage-fetcher
+```
+
+Monorepo consumers: `"@juanbenjumea/pi-provider-usage-fetcher": "file:../opencode-go-usage"`.
+
+## Unified Dispatch
+
+```ts
+import { detectProvider, fetchProviderUsage, fetchAllProviderUsage } from "@juanbenjumea/pi-provider-usage-fetcher";
+
+// Automatically detects alias ("anthropic", "github-copilot", "opencode", etc.)
+const canonical = detectProvider("anthropic"); // "claude"
+
+// Fetches and normalizes quota snapshot across any supported provider
+const snapshot = await fetchProviderUsage("anthropic", { apiKey: "..." });
+// { provider: "Claude", windows: [ { label: "5h", usedPercent: 45, resetsIn: "1h30m" }, ... ], fetchedAt }
+
+// Or collect several providers concurrently; unknown providers are omitted.
+const snapshots = await fetchAllProviderUsage(["anthropic", "openai-codex", "cursor"]);
+```
+
+## OpenCode Go (API-first)
+
+```ts
+import { fetchUsageApi } from "@juanbenjumea/pi-provider-usage-fetcher";
+
+const usage = await fetchUsageApi(process.env.OPENCODE_GO_KEY!);
+// { rolling, weekly, monthly, error? }
+```
+
+## Cursor / CommandCode
+
+```ts
+import { fetchCursorUsage } from "@juanbenjumea/pi-provider-usage-fetcher/cursor.ts";
+import { fetchCommandCodeUsage } from "@juanbenjumea/pi-provider-usage-fetcher/commandcode.ts";
+import { fetchOpenferenceUsage } from "@juanbenjumea/pi-provider-usage-fetcher/openference.ts";
+
+// Footer labels (Plan / Auto / API)
+await fetchCursorUsage();
+
+// agentq labels (total / auto-composer / api-models)
+await fetchCursorUsage({ labelStyle: "agentq" });
+
+await fetchCommandCodeUsage();
+
+// Uses the dashboard profile endpoint (openference.com/api/user/me), which the
+// inference API key authenticates via Bearer. window = usage.windowQuotaUsed /
+// plan.requestsPerWindow, week = usage.weekQuotaUsed / plan.requestsPerWeek.
+const openference = await fetchOpenferenceUsage(process.env.OPENFERENCE_API_KEY);
+```
+
+Auth resolution order: provider-specific explicit key → environment variable → `auth.json` credential. For Cursor and CommandCode cookies, the existing order is `quota-sessions.json` → env vars → legacy `auth.json` cookies → CodexBar manual cookies → (Cursor only) desktop app token.
+
+## Consumers
+
+- `@juanbenjumea/pi-dynamic-footer` — subscription quota bars
+- `@juanbenjumea/pi-multi-opencode-go` — failover usage polling
+- **agentq** — `data/quota.json` collector
+
+## Package rename
+
+This package is published as `@juanbenjumea/pi-provider-usage-fetcher`. Existing consumers of the former `@juanbenjumea/opencode-go-usage` npm package must switch their dependency and imports when adopting this package; the old package identity remains separate.

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./lib/opencode-go/types.ts";
+export * from "./lib/opencode-go/dashboard.ts";
+export * from "./lib/opencode-go/fetch.ts";
+export * from "./lib/opencode-go/usage-api.ts";
+export * from "./lib/shared/quota-types.ts";
+export * from "./lib/shared/format.ts";
+export * from "./lib/auth/auth.ts";
+export * from "./lib/auth/web-sessions.ts";
+export * from "./lib/auth/codexbar-config.ts";
+export * from "./lib/cursor/cursor-auth.ts";
+export * from "./lib/cursor/cursor.ts";
+export * from "./lib/commandcode/commandcode.ts";
+export * from "./lib/openference/openference.ts";
+export * from "./lib/opencode-go/opencode-go.ts";
+export * from "./lib/claude/claude.ts";
+export * from "./lib/codex/codex.ts";
+export * from "./lib/cline/cline.ts";
+export * from "./lib/umans/umans.ts";
+export * from "./lib/copilot/copilot.ts";
+export * from "./lib/gemini/gemini.ts";
+export * from "./lib/kimi/kimi.ts";
+export * from "./lib/synthetic/synthetic.ts";
+export * from "./lib/zai/zai.ts";
+export * from "./lib/provider/dispatch.ts";

package/dist/index.js

@@ -0,0 +1,24 @@
+export * from "./lib/opencode-go/types.js";
+export * from "./lib/opencode-go/dashboard.js";
+export * from "./lib/opencode-go/fetch.js";
+export * from "./lib/opencode-go/usage-api.js";
+export * from "./lib/shared/quota-types.js";
+export * from "./lib/shared/format.js";
+export * from "./lib/auth/auth.js";
+export * from "./lib/auth/web-sessions.js";
+export * from "./lib/auth/codexbar-config.js";
+export * from "./lib/cursor/cursor-auth.js";
+export * from "./lib/cursor/cursor.js";
+export * from "./lib/commandcode/commandcode.js";
+export * from "./lib/openference/openference.js";
+export * from "./lib/opencode-go/opencode-go.js";
+export * from "./lib/claude/claude.js";
+export * from "./lib/codex/codex.js";
+export * from "./lib/cline/cline.js";
+export * from "./lib/umans/umans.js";
+export * from "./lib/copilot/copilot.js";
+export * from "./lib/gemini/gemini.js";
+export * from "./lib/kimi/kimi.js";
+export * from "./lib/synthetic/synthetic.js";
+export * from "./lib/zai/zai.js";
+export * from "./lib/provider/dispatch.js";

package/dist/lib/auth/auth.d.ts

@@ -0,0 +1,12 @@
+type JsonObject = Record<string, unknown>;
+export declare function getAgentDir(): string;
+export declare function loadAuthJson(): JsonObject;
+/**
+ * Extract a provider block from auth.json as a plain object, when present.
+ * The raw auth entry narrows to `object` after a typeof check, which has no
+ * index signature, so this casts once to keep callers typed.
+ */
+export declare function authProviderBlock(auth: JsonObject, key: string): JsonObject | undefined;
+export declare function resolveAuthValue(value: unknown): string | undefined;
+export declare function authCredential(...keys: string[]): string | undefined;
+export {};

package/dist/lib/auth/auth.js

@@ -0,0 +1,67 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function getAgentDir() {
+    return process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent");
+}
+export function loadAuthJson() {
+    const authPath = join(getAgentDir(), "auth.json");
+    try {
+        if (existsSync(authPath)) {
+            return JSON.parse(readFileSync(authPath, "utf-8"));
+        }
+    }
+    catch {
+        // Missing or malformed auth should render as unavailable, not break pi.
+    }
+    return {};
+}
+/**
+ * Extract a provider block from auth.json as a plain object, when present.
+ * The raw auth entry narrows to `object` after a typeof check, which has no
+ * index signature, so this casts once to keep callers typed.
+ */
+export function authProviderBlock(auth, key) {
+    const entry = auth[key];
+    return entry && typeof entry === "object" ? entry : undefined;
+}
+export function resolveAuthValue(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.startsWith("!"))
+        return undefined;
+    if (/^[A-Z][A-Z0-9_]*$/.test(trimmed))
+        return process.env[trimmed] || undefined;
+    if (trimmed.startsWith("$$"))
+        return trimmed.slice(1);
+    if (trimmed.startsWith("$!"))
+        return trimmed.slice(1);
+    if (trimmed.startsWith("$")) {
+        const name = trimmed.slice(1).replace(/^\{(.*)\}$/, "$1");
+        return process.env[name] || undefined;
+    }
+    return trimmed;
+}
+export function authCredential(...keys) {
+    const auth = loadAuthJson();
+    for (const key of keys) {
+        const entry = auth[key];
+        if (typeof entry === "string") {
+            const value = resolveAuthValue(entry);
+            if (value)
+                return value;
+            continue;
+        }
+        if (entry && typeof entry === "object") {
+            for (const field of ["access", "key", "token", "refresh", "cookie"]) {
+                const value = resolveAuthValue(entry[field]);
+                if (value)
+                    return value;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/lib/auth/codexbar-config.d.ts

@@ -0,0 +1,2 @@
+export declare function codexBarProviderCookie(providerId: string): string | undefined;
+export declare function envCookie(name: string): string | undefined;

package/dist/lib/auth/codexbar-config.js

@@ -0,0 +1,38 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function codexBarConfigPath() {
+    const explicit = process.env.CODEXBAR_CONFIG?.trim();
+    if (explicit)
+        return explicit;
+    const xdg = process.env.XDG_CONFIG_HOME?.trim();
+    const xdgPath = xdg && xdg.startsWith("/") ? join(xdg, "codexbar", "config.json") : undefined;
+    const defaultPath = join(homedir(), ".config", "codexbar", "config.json");
+    const legacyPath = join(homedir(), ".codexbar", "config.json");
+    if (xdgPath && existsSync(xdgPath))
+        return xdgPath;
+    if (existsSync(defaultPath))
+        return defaultPath;
+    if (existsSync(legacyPath))
+        return legacyPath;
+    return undefined;
+}
+export function codexBarProviderCookie(providerId) {
+    const configPath = codexBarConfigPath();
+    if (!configPath)
+        return undefined;
+    try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        const providers = Array.isArray(config.providers) ? config.providers : [];
+        const entry = providers.find((provider) => provider?.id === providerId);
+        const cookieHeader = entry?.cookieHeader;
+        return typeof cookieHeader === "string" && cookieHeader.trim() ? cookieHeader.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function envCookie(name) {
+    const value = process.env[name]?.trim();
+    return value || undefined;
+}

package/dist/lib/auth/web-sessions.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_QUOTA_SESSIONS_FILE = "quota-sessions.json";
+type JsonObject = Record<string, unknown>;
+export declare function loadQuotaSessions(): JsonObject;
+/** Cookie header for a provider id in quota-sessions.json (string or { cookie }). */
+export declare function quotaSessionCookie(providerId: string): string | undefined;
+export {};

package/dist/lib/auth/web-sessions.js

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir, resolveAuthValue } from "./auth.js";
+export const DEFAULT_QUOTA_SESSIONS_FILE = "quota-sessions.json";
+function quotaSessionsPath() {
+    const override = process.env.PI_QUOTA_SESSIONS_FILE?.trim();
+    if (override)
+        return override;
+    return join(getAgentDir(), DEFAULT_QUOTA_SESSIONS_FILE);
+}
+export function loadQuotaSessions() {
+    const path = quotaSessionsPath();
+    try {
+        if (existsSync(path)) {
+            return JSON.parse(readFileSync(path, "utf-8"));
+        }
+    }
+    catch {
+        // Missing or malformed sessions should render as unavailable, not break pi.
+    }
+    return {};
+}
+/** Cookie header for a provider id in quota-sessions.json (string or { cookie }). */
+export function quotaSessionCookie(providerId) {
+    const sessions = loadQuotaSessions();
+    const entry = sessions[providerId];
+    if (typeof entry === "string") {
+        return resolveAuthValue(entry)?.trim();
+    }
+    if (entry && typeof entry === "object") {
+        const cookie = resolveAuthValue(entry.cookie);
+        if (cookie)
+            return cookie.trim();
+    }
+    return undefined;
+}

package/dist/lib/claude/claude.d.ts

@@ -0,0 +1,2 @@
+import type { QuotaFetchOptions, QuotaSnapshot } from "../shared/quota-types.ts";
+export declare function fetchClaudeUsage(options?: QuotaFetchOptions): Promise<QuotaSnapshot>;

package/dist/lib/claude/claude.js

@@ -0,0 +1,51 @@
+import { execFile } from "node:child_process";
+import { authCredential } from "../auth/auth.js";
+import { formatResetTime, normalizePercent, safeError } from "../shared/format.js";
+import { fetchJson } from "../shared/http.js";
+export async function fetchClaudeUsage(options = {}) {
+    let token = options.apiKey || authCredential("anthropic");
+    if (!token) {
+        try {
+            // Resolve the macOS keychain credential asynchronously so a slow
+            // keychain lookup never blocks the TUI thread.
+            const keychain = await new Promise((resolve, reject) => {
+                execFile("/usr/bin/security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"], { encoding: "utf-8", timeout: 2000 }, (err, stdout) => (err ? reject(err) : resolve(stdout)));
+            }).then((s) => s.trim());
+            const parsed = JSON.parse(keychain);
+            token = parsed.claudeAiOauth?.accessToken;
+        }
+        catch {
+            // No Claude CLI credential.
+        }
+    }
+    if (!token)
+        return { provider: "Claude", windows: [], error: "no-auth", fetchedAt: Date.now() };
+    try {
+        const { data } = await fetchJson("https://api.anthropic.com/api/oauth/usage", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "anthropic-beta": "oauth-2025-04-20",
+            },
+        }, options.timeoutMs ?? 10_000, options.fetchImpl ?? fetch);
+        const windows = [];
+        const addWindow = (source, label) => {
+            const utilization = Number(source?.utilization);
+            if (!Number.isFinite(utilization))
+                return;
+            windows.push({
+                label,
+                usedPercent: normalizePercent(utilization),
+                resetsIn: source.resets_at ? formatResetTime(new Date(source.resets_at)) : undefined,
+            });
+        };
+        addWindow(data.five_hour, "5h");
+        addWindow(data.seven_day, "Week");
+        // Some subscription variants expose a monthly bucket; do not synthesize
+        // one when the endpoint omits it.
+        addWindow(data.monthly ?? data.thirty_day ?? data.thirty_day_window, "Month");
+        return { provider: "Claude", windows, fetchedAt: Date.now() };
+    }
+    catch (error) {
+        return { provider: "Claude", windows: [], error: safeError(error), fetchedAt: Date.now() };
+    }
+}

package/dist/lib/cline/cline.d.ts

@@ -0,0 +1,7 @@
+import type { QuotaFetchOptions, QuotaSnapshot } from "../shared/quota-types.ts";
+export interface ClineUsageItem {
+    createdAt?: string;
+    costUsd?: number;
+}
+export declare function clineApiKey(explicit?: string): string | undefined;
+export declare function fetchClineUsage(apiKeyOrOptions?: string | QuotaFetchOptions, maybeOptions?: QuotaFetchOptions): Promise<QuotaSnapshot>;

package/dist/lib/cline/cline.js

@@ -0,0 +1,94 @@
+import { authCredential, resolveAuthValue } from "../auth/auth.js";
+import { clampPercent, formatResetTime, safeError } from "../shared/format.js";
+import { fetchJson } from "../shared/http.js";
+const CLINE_BASE_URL = "https://api.cline.bot";
+const CLINE_PAGE_LIMIT = 100;
+const CLINE_MAX_PAGES = 100;
+function clineUrl(path) {
+    return new URL(path, CLINE_BASE_URL).toString();
+}
+export function clineApiKey(explicit) {
+    return explicit || resolveAuthValue(process.env.CLINE_API_KEY) || authCredential("cline-pass", "clinepass");
+}
+function parseClineDate(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) ? date : undefined;
+}
+function clineWindow(now, label, durationMs, limitUnits, items) {
+    if (!Number.isFinite(limitUnits) || limitUnits <= 0)
+        return null;
+    const start = now - durationMs;
+    let usedUnits = 0;
+    let oldest;
+    for (const item of items) {
+        const createdAt = parseClineDate(item.createdAt)?.getTime();
+        if (createdAt === undefined || createdAt < start || createdAt > now)
+            continue;
+        const cost = Number(item.costUsd);
+        if (Number.isFinite(cost))
+            usedUnits += cost;
+        oldest = oldest === undefined ? createdAt : Math.min(oldest, createdAt);
+    }
+    const usedPercent = limitUnits > 0 ? clampPercent((usedUnits / limitUnits) * 100) : 0;
+    const resetAt = oldest === undefined ? undefined : new Date(oldest + durationMs);
+    return { label, usedPercent, resetsIn: resetAt ? formatResetTime(resetAt) : undefined };
+}
+export async function fetchClineUsage(apiKeyOrOptions, maybeOptions) {
+    const options = typeof apiKeyOrOptions === "object" && apiKeyOrOptions !== null
+        ? apiKeyOrOptions
+        : (maybeOptions ?? {});
+    const explicitKey = typeof apiKeyOrOptions === "string" ? apiKeyOrOptions : options.apiKey;
+    const apiKey = clineApiKey(explicitKey);
+    if (!apiKey) {
+        return { provider: "ClinePass", windows: [], error: "no-auth", fetchedAt: Date.now() };
+    }
+    const timeoutMs = options.timeoutMs ?? 10_000;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    try {
+        const headers = { Authorization: `Bearer ${apiKey}`, Accept: "application/json", "User-Agent": "pi-obs-footer" };
+        const me = await fetchJson(clineUrl("/api/v1/users/me"), { headers }, timeoutMs, fetchImpl);
+        const userId = typeof me.data?.data?.id === "string" ? me.data.data.id : "";
+        if (!userId)
+            return { provider: "ClinePass", windows: [], error: "invalid-response", fetchedAt: Date.now() };
+        const plans = await fetchJson(clineUrl("/api/v1/plans"), { headers }, timeoutMs, fetchImpl);
+        const planList = Array.isArray(plans.data?.data) ? plans.data.data : [];
+        const threshold = planList.find((plan) => plan?.isActive && plan?.entitlements?.cline_pass?.enabled && plan?.entitlements?.cline_pass?.inferenceCapThreshold)?.entitlements?.cline_pass?.inferenceCapThreshold;
+        if (!threshold)
+            return { provider: "ClinePass", windows: [], error: "no-active-plan", fetchedAt: Date.now() };
+        const items = [];
+        let cursor = "";
+        const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
+        for (let page = 0; page < CLINE_MAX_PAGES; page++) {
+            const url = new URL(clineUrl(`/api/v1/users/${encodeURIComponent(userId)}/usages`));
+            url.searchParams.set("limit", String(CLINE_PAGE_LIMIT));
+            if (cursor)
+                url.searchParams.set("cursor", cursor);
+            const response = await fetchJson(url.toString(), { headers }, timeoutMs, fetchImpl);
+            const data = response.data?.data;
+            const pageItems = Array.isArray(data?.items) ? data.items : [];
+            items.push(...pageItems);
+            const oldest = pageItems
+                .map((item) => parseClineDate(item.createdAt)?.getTime())
+                .filter((value) => value !== undefined)
+                .reduce((min, value) => min === undefined ? value : Math.min(min, value), undefined);
+            cursor = typeof data?.nextToken === "string" ? data.nextToken.trim() : "";
+            if (!cursor || pageItems.length === 0 || (oldest !== undefined && oldest < cutoff))
+                break;
+        }
+        const now = Date.now();
+        return {
+            provider: "ClinePass",
+            windows: [
+                clineWindow(now, "5h", 5 * 60 * 60 * 1000, Number(threshold.last5HoursUsageCostUSDPerUser), items),
+                clineWindow(now, "Week", 7 * 24 * 60 * 60 * 1000, Number(threshold.last7daysUsageCostUSDPerUser), items),
+                clineWindow(now, "Month", 30 * 24 * 60 * 60 * 1000, Number(threshold.last30daysUsageCostUSDPerUser), items),
+            ].filter((window) => window !== null),
+            fetchedAt: now,
+        };
+    }
+    catch (error) {
+        return { provider: "ClinePass", windows: [], error: safeError(error), fetchedAt: Date.now() };
+    }
+}

package/dist/lib/codex/codex.d.ts

@@ -0,0 +1,2 @@
+import type { QuotaFetchOptions, QuotaSnapshot } from "../shared/quota-types.ts";
+export declare function fetchCodexUsage(options?: QuotaFetchOptions): Promise<QuotaSnapshot>;

package/dist/lib/codex/codex.js

@@ -0,0 +1,56 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { authCredential, loadAuthJson } from "../auth/auth.js";
+import { clampPercent, formatResetSeconds, formatResetTime, safeError } from "../shared/format.js";
+import { fetchJson } from "../shared/http.js";
+export async function fetchCodexUsage(options = {}) {
+    let token = options.apiKey || authCredential("openai-codex");
+    let accountId = loadAuthJson()["openai-codex"]?.accountId;
+    if (!token) {
+        const codexPath = join(process.env.CODEX_HOME || join(homedir(), ".codex"), "auth.json");
+        try {
+            const data = JSON.parse(readFileSync(codexPath, "utf-8"));
+            token = data.OPENAI_API_KEY || data.tokens?.access_token;
+            accountId ||= data.tokens?.account_id;
+        }
+        catch {
+            // No Codex credential.
+        }
+    }
+    if (!token)
+        return { provider: "Codex", windows: [], error: "no-auth", fetchedAt: Date.now() };
+    try {
+        const headers = {
+            Authorization: `Bearer ${token}`,
+            "User-Agent": "pi-agent",
+            Accept: "application/json",
+        };
+        if (accountId)
+            headers["ChatGPT-Account-Id"] = accountId;
+        const { data } = await fetchJson("https://chatgpt.com/backend-api/wham/usage", { headers }, options.timeoutMs ?? 10_000, options.fetchImpl ?? fetch);
+        const windows = [];
+        const rateLimit = data.rate_limit ?? {};
+        for (const [label, window] of [
+            ["5h", rateLimit.primary_window],
+            ["Week", rateLimit.secondary_window],
+            ["Month", rateLimit.monthly_window ?? rateLimit.tertiary_window],
+        ]) {
+            if (!window)
+                continue;
+            const resetAt = typeof window.reset_at === "number" ? new Date(window.reset_at * 1000) : undefined;
+            const usedPercent = Number(window.used_percent);
+            if (!Number.isFinite(usedPercent))
+                continue;
+            windows.push({
+                label,
+                usedPercent: clampPercent(usedPercent),
+                resetsIn: resetAt ? formatResetTime(resetAt) : formatResetSeconds(Number(window.reset_after_seconds)),
+            });
+        }
+        return { provider: "Codex", windows, fetchedAt: Date.now() };
+    }
+    catch (error) {
+        return { provider: "Codex", windows: [], error: safeError(error), fetchedAt: Date.now() };
+    }
+}

package/dist/lib/commandcode/commandcode.d.ts

@@ -0,0 +1,13 @@
+import type { QuotaSnapshot, QuotaWindow } from "../shared/quota-types.ts";
+export declare function resolveCommandCodeCookieHeader(): string | undefined;
+export declare function parseCommandCodeCredits(data: any): {
+    monthlyRemaining: number;
+    fiveHour?: QuotaWindow;
+    weekly?: QuotaWindow;
+};
+export declare function parseCommandCodeSubscription(data: any): {
+    planId?: string;
+    periodEnd?: Date;
+};
+export declare function buildCommandCodeWindows(credits: ReturnType<typeof parseCommandCodeCredits>, subscription: ReturnType<typeof parseCommandCodeSubscription>): QuotaWindow[];
+export declare function fetchCommandCodeUsage(): Promise<QuotaSnapshot>;