@love-moon/ai-sdk 0.3.2 → 0.4.0

package/dist/manager/install.js

@@ -0,0 +1,117 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+const DEFAULT_TIMEOUT_MS = 3000;
+const require = createRequire(import.meta.url);
+function execCapture(cmd, args, timeoutMs) {
+    return new Promise((resolve) => {
+        const proc = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                proc.kill("SIGKILL");
+                resolve({ code: null, stdout, stderr, error: new Error("timeout") });
+            }
+        }, timeoutMs);
+        proc.stdout?.on("data", (b) => (stdout += b.toString()));
+        proc.stderr?.on("data", (b) => (stderr += b.toString()));
+        proc.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code: null, stdout, stderr, error: err });
+        });
+        proc.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr });
+        });
+    });
+}
+async function which(bin, timeoutMs) {
+    const res = await execCapture("which", [bin], timeoutMs);
+    if (res.code !== 0)
+        return undefined;
+    const p = res.stdout.trim().split("\n")[0];
+    return p || undefined;
+}
+export async function checkInstall(tool, opts = {}) {
+    if (tool === "copilot") {
+        return checkCopilotSdkInstall();
+    }
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const bin = tool; // codex / claude
+    const path = await which(bin, timeoutMs);
+    if (!path) {
+        return { installed: false, error: `${bin} not found in PATH` };
+    }
+    const res = await execCapture(bin, ["--version"], timeoutMs);
+    if (res.error || res.code !== 0) {
+        return {
+            installed: true,
+            path,
+            error: res.error?.message ?? (res.stderr.trim() || `exit ${res.code}`),
+        };
+    }
+    const rawLine = (res.stdout.trim() || res.stderr.trim()).split("\n")[0] ?? "";
+    return { installed: true, path, version: extractSemver(rawLine) ?? rawLine };
+}
+/** Pull the first semver-looking token out of an arbitrary `--version` line. */
+function extractSemver(line) {
+    const m = /\d+\.\d+(?:\.\d+)?(?:[-+][\w.]+)?/.exec(line);
+    return m ? m[0] : undefined;
+}
+export async function checkInstallAll(opts) {
+    const [codex, claude, kimi, copilot] = await Promise.all([
+        checkInstall("codex", opts),
+        checkInstall("claude", opts),
+        checkInstall("kimi", opts),
+        checkInstall("copilot", opts),
+    ]);
+    return { codex, claude, kimi, copilot };
+}
+async function checkCopilotSdkInstall() {
+    try {
+        const entryPath = require.resolve("@github/copilot-sdk");
+        const version = await findPackageVersionForEntry(entryPath, "@github/copilot-sdk");
+        return {
+            installed: true,
+            path: "@github/copilot-sdk",
+            version: version ?? "installed",
+        };
+    }
+    catch (err) {
+        return {
+            installed: false,
+            error: `@github/copilot-sdk not available: ${err?.message ?? err}`,
+        };
+    }
+}
+/** Exported for tests. */
+export async function findPackageVersionForEntry(entryPath, packageName) {
+    let dir = dirname(entryPath);
+    while (true) {
+        const pkgPath = join(dir, "package.json");
+        try {
+            const payload = JSON.parse(await readFile(pkgPath, "utf8"));
+            if (payload.name === packageName) {
+                const version = typeof payload.version === "string" ? payload.version.trim() : "";
+                return version || undefined;
+            }
+        }
+        catch {
+            // Walk upward until we hit the package root or filesystem root.
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}

package/dist/manager/manager.d.ts

@@ -0,0 +1,51 @@
+import { type GetCodexQuotaOptions } from "./quota/codex.js";
+import { type GetClaudeQuotaOptions } from "./quota/claude.js";
+import { type GetKimiQuotaOptions } from "./quota/kimi.js";
+import { type GetCopilotQuotaOptions } from "./quota/copilot.js";
+import { type GetExternalQuotaListOptions, type GetExternalQuotaOptions } from "./quota/external.js";
+import type { AiManagerConfig, CodexAccount, CodexQuota, ClaudeQuota, ExternalQuota, ExternalQuotaList, KimiQuota, CopilotQuota, InstallStatus, NetworkStatus, SwitchResult, Tool } from "./types.js";
+export interface AiManagerOptions {
+    /** Path to conductor config.yaml. Default: ~/.conductor/config.yaml */
+    configPath?: string;
+    /** Path to the active codex auth.json. Default: ~/.codex/auth.json */
+    codexAuthPath?: string;
+    /** Pre-loaded config; skips loading from disk if provided. */
+    config?: AiManagerConfig;
+}
+export declare class AiManager {
+    private readonly configPath;
+    private readonly codexAuthPath;
+    private readonly configOverride?;
+    private cached?;
+    constructor(opts?: AiManagerOptions);
+    /**
+     * Read the latest ai_manager config. Cached against the config file's mtime,
+     * so edits to ~/.conductor/config.yaml are picked up immediately without
+     * restarting the daemon, while a 30s polling cycle does not re-parse YAML
+     * on every action. Falls back to always-reload if stat() fails.
+     * The `config` constructor option short-circuits disk reads (used by tests).
+     */
+    getConfig(): Promise<AiManagerConfig>;
+    /** Force the next getConfig() call to re-read the file from disk. */
+    reloadConfig(): Promise<AiManagerConfig>;
+    checkInstall(tool: Tool): Promise<InstallStatus>;
+    checkInstallAll(): Promise<Record<Tool, InstallStatus>>;
+    checkNetwork(tool: Tool): Promise<NetworkStatus>;
+    checkNetworkAll(): Promise<Record<Tool, NetworkStatus>>;
+    getCodexQuota(opts?: GetCodexQuotaOptions): Promise<CodexQuota>;
+    /**
+     * Read the last-cached codex quota for a specific auth file path, without
+     * any network call. Enables `list_accounts` to return a "last known"
+     * snapshot per account so the web UI can restore inactive-account quotas
+     * across page refreshes.
+     */
+    readCachedCodexQuota(authPath: string): Promise<CodexQuota | null>;
+    getClaudeQuota(opts?: GetClaudeQuotaOptions): Promise<ClaudeQuota>;
+    getKimiQuota(opts?: GetKimiQuotaOptions): Promise<KimiQuota>;
+    getCopilotQuota(opts?: GetCopilotQuotaOptions): Promise<CopilotQuota>;
+    getExternalQuota(opts: GetExternalQuotaOptions): Promise<ExternalQuota>;
+    getExternalQuotaList(opts: GetExternalQuotaListOptions): Promise<ExternalQuotaList>;
+    listCodexAccounts(): Promise<CodexAccount[]>;
+    getCurrentCodexAccount(): Promise<CodexAccount | null>;
+    switchCodexAccount(name: string): Promise<SwitchResult>;
+}

package/dist/manager/manager.js

@@ -0,0 +1,105 @@
+import { stat } from "node:fs/promises";
+import { loadAiManagerConfig } from "./config.js";
+import { getCurrentCodexAccount, listCodexAccounts, switchCodexAccount } from "./account.js";
+import { checkInstall, checkInstallAll } from "./install.js";
+import { checkNetwork, checkNetworkAll } from "./network.js";
+import { getCodexQuota, readCachedCodexQuota } from "./quota/codex.js";
+import { getClaudeQuota } from "./quota/claude.js";
+import { getKimiQuota } from "./quota/kimi.js";
+import { getCopilotQuota } from "./quota/copilot.js";
+import { getExternalQuota, getExternalQuotaList, } from "./quota/external.js";
+import { DEFAULT_CODEX_AUTH, DEFAULT_CONDUCTOR_CONFIG } from "./paths.js";
+export class AiManager {
+    configPath;
+    codexAuthPath;
+    configOverride;
+    cached;
+    constructor(opts = {}) {
+        this.configPath = opts.configPath ?? DEFAULT_CONDUCTOR_CONFIG;
+        this.codexAuthPath = opts.codexAuthPath ?? DEFAULT_CODEX_AUTH;
+        this.configOverride = opts.config;
+    }
+    /**
+     * Read the latest ai_manager config. Cached against the config file's mtime,
+     * so edits to ~/.conductor/config.yaml are picked up immediately without
+     * restarting the daemon, while a 30s polling cycle does not re-parse YAML
+     * on every action. Falls back to always-reload if stat() fails.
+     * The `config` constructor option short-circuits disk reads (used by tests).
+     */
+    async getConfig() {
+        if (this.configOverride)
+            return this.configOverride;
+        try {
+            const st = await stat(this.configPath);
+            const mtimeMs = st.mtimeMs;
+            if (this.cached && this.cached.mtimeMs === mtimeMs) {
+                return this.cached.value;
+            }
+            const value = await loadAiManagerConfig(this.configPath);
+            this.cached = { mtimeMs, value };
+            return value;
+        }
+        catch {
+            // ENOENT or stat failure → bypass cache and let loadAiManagerConfig
+            // handle missing-file semantics (returns empty config).
+            this.cached = undefined;
+            return loadAiManagerConfig(this.configPath);
+        }
+    }
+    /** Force the next getConfig() call to re-read the file from disk. */
+    reloadConfig() {
+        this.cached = undefined;
+        return this.getConfig();
+    }
+    checkInstall(tool) {
+        return checkInstall(tool);
+    }
+    checkInstallAll() {
+        return checkInstallAll();
+    }
+    checkNetwork(tool) {
+        return checkNetwork(tool);
+    }
+    checkNetworkAll() {
+        return checkNetworkAll();
+    }
+    getCodexQuota(opts) {
+        return getCodexQuota({ codexAuthPath: this.codexAuthPath, ...opts });
+    }
+    /**
+     * Read the last-cached codex quota for a specific auth file path, without
+     * any network call. Enables `list_accounts` to return a "last known"
+     * snapshot per account so the web UI can restore inactive-account quotas
+     * across page refreshes.
+     */
+    readCachedCodexQuota(authPath) {
+        return readCachedCodexQuota(authPath);
+    }
+    getClaudeQuota(opts) {
+        return getClaudeQuota(opts);
+    }
+    getKimiQuota(opts) {
+        return getKimiQuota(opts);
+    }
+    getCopilotQuota(opts) {
+        return getCopilotQuota(opts);
+    }
+    getExternalQuota(opts) {
+        return getExternalQuota({ configPath: this.configPath, ...opts });
+    }
+    getExternalQuotaList(opts) {
+        return getExternalQuotaList({ configPath: this.configPath, ...opts });
+    }
+    async listCodexAccounts() {
+        const cfg = await this.getConfig();
+        return listCodexAccounts(cfg, this.codexAuthPath);
+    }
+    async getCurrentCodexAccount() {
+        const cfg = await this.getConfig();
+        return getCurrentCodexAccount(cfg, this.codexAuthPath);
+    }
+    async switchCodexAccount(name) {
+        const cfg = await this.getConfig();
+        return switchCodexAccount(cfg, name, this.codexAuthPath);
+    }
+}

package/dist/manager/network.d.ts

@@ -0,0 +1,8 @@
+import type { NetworkStatus, Tool } from "./types.js";
+export declare function checkNetwork(tool: Tool, opts?: {
+    timeoutMs?: number;
+    endpoint?: string;
+}): Promise<NetworkStatus>;
+export declare function checkNetworkAll(opts?: {
+    timeoutMs?: number;
+}): Promise<Record<Tool, NetworkStatus>>;

package/dist/manager/network.js

@@ -0,0 +1,46 @@
+const ENDPOINTS = {
+    codex: "https://chatgpt.com/",
+    claude: "https://api.anthropic.com/v1/messages",
+    kimi: "https://api.kimi.com/coding/v1/usages",
+    copilot: "https://api.githubcopilot.com/",
+};
+const DEFAULT_TIMEOUT_MS = 5000;
+export async function checkNetwork(tool, opts = {}) {
+    const endpoint = opts.endpoint ?? ENDPOINTS[tool];
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const start = Date.now();
+    try {
+        // Unauthenticated HEAD; we only care whether the host is reachable.
+        // api.anthropic.com returns 401/405 on HEAD, which still counts as reachable.
+        const res = await fetch(endpoint, { method: "HEAD", signal: controller.signal });
+        const latencyMs = Date.now() - start;
+        return {
+            reachable: true,
+            latencyMs,
+            httpStatus: res.status,
+            endpoint,
+        };
+    }
+    catch (err) {
+        return {
+            reachable: false,
+            latencyMs: Date.now() - start,
+            endpoint,
+            error: err?.name === "AbortError" ? "timeout" : err?.message ?? String(err),
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function checkNetworkAll(opts) {
+    const [codex, claude, kimi, copilot] = await Promise.all([
+        checkNetwork("codex", opts),
+        checkNetwork("claude", opts),
+        checkNetwork("kimi", opts),
+        checkNetwork("copilot", opts),
+    ]);
+    return { codex, claude, kimi, copilot };
+}

package/dist/manager/paths.d.ts

@@ -0,0 +1,6 @@
+export declare function expandHome(p: string): string;
+export declare const DEFAULT_CONDUCTOR_CONFIG: string;
+export declare const DEFAULT_CODEX_AUTH: string;
+export declare const DEFAULT_CODEX_CONFIG: string;
+export declare const DEFAULT_KIMI_CREDENTIAL: string;
+export declare const DEFAULT_QUOTA_CACHE_DIR: string;

package/dist/manager/paths.js

@@ -0,0 +1,16 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function expandHome(p) {
+    if (!p)
+        return p;
+    if (p === "~")
+        return homedir();
+    if (p.startsWith("~/"))
+        return join(homedir(), p.slice(2));
+    return p;
+}
+export const DEFAULT_CONDUCTOR_CONFIG = join(homedir(), ".conductor", "config.yaml");
+export const DEFAULT_CODEX_AUTH = join(homedir(), ".codex", "auth.json");
+export const DEFAULT_CODEX_CONFIG = join(homedir(), ".codex", "config.toml");
+export const DEFAULT_KIMI_CREDENTIAL = join(homedir(), ".kimi", "credentials", "kimi-code.json");
+export const DEFAULT_QUOTA_CACHE_DIR = join(homedir(), ".conductor", "cache", "ai-manager");

package/dist/manager/quota/cache.d.ts

@@ -0,0 +1,9 @@
+export interface CacheEntry<T> {
+    fetchedAt: number;
+    value: T;
+}
+export declare function fingerprintKey(parts: string[]): string;
+export declare function readCache<T>(file: string): Promise<CacheEntry<T> | null>;
+export declare function writeCache<T>(file: string, value: T): Promise<CacheEntry<T>>;
+export declare function cacheFile(tool: string, fingerprint: string, dir?: string): string;
+export declare function isFresh(entry: CacheEntry<unknown> | null, ttlSeconds: number): boolean;

package/dist/manager/quota/cache.js

@@ -0,0 +1,33 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { createHash } from "node:crypto";
+import { DEFAULT_QUOTA_CACHE_DIR } from "../paths.js";
+export function fingerprintKey(parts) {
+    const h = createHash("sha1");
+    for (const p of parts)
+        h.update(p);
+    return h.digest("hex").slice(0, 16);
+}
+export async function readCache(file) {
+    try {
+        const raw = await readFile(file, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeCache(file, value) {
+    const entry = { fetchedAt: Math.floor(Date.now() / 1000), value };
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(entry), "utf8");
+    return entry;
+}
+export function cacheFile(tool, fingerprint, dir = DEFAULT_QUOTA_CACHE_DIR) {
+    return join(dir, `quota-${tool}-${fingerprint}.json`);
+}
+export function isFresh(entry, ttlSeconds) {
+    if (!entry)
+        return false;
+    return Math.floor(Date.now() / 1000) - entry.fetchedAt < ttlSeconds;
+}

package/dist/manager/quota/claude.d.ts

@@ -0,0 +1,19 @@
+import type { ClaudeQuota } from "../types.js";
+export interface ClaudeCredential {
+    kind: "api-key" | "oauth";
+    token: string;
+    /** JSON source string (for fingerprinting). */
+    fingerprintInput: string;
+}
+export interface GetClaudeQuotaOptions {
+    /** Cache TTL in seconds. Default 60. */
+    ttlSeconds?: number;
+    forceRefresh?: boolean;
+    timeoutMs?: number;
+    model?: string;
+    cacheDir?: string;
+    /** Override credential resolution (mainly for tests). */
+    credential?: ClaudeCredential;
+}
+export declare function resolveClaudeCredential(): Promise<ClaudeCredential | null>;
+export declare function getClaudeQuota(opts?: GetClaudeQuotaOptions): Promise<ClaudeQuota>;

package/dist/manager/quota/claude.js

@@ -0,0 +1,193 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { headersToMap, num, str } from "./headers.js";
+import { cacheFile, fingerprintKey, isFresh, readCache, writeCache } from "./cache.js";
+const MESSAGES_URL = "https://api.anthropic.com/v1/messages";
+const DEFAULT_TTL = 60;
+const DEFAULT_TIMEOUT_MS = 20000;
+const CLAUDE_CODE_SYSTEM_PROMPT = "You are Claude Code, Anthropic's official CLI for Claude.";
+export async function resolveClaudeCredential() {
+    const envKey = process.env.ANTHROPIC_API_KEY;
+    if (envKey && envKey.length > 10) {
+        return { kind: "api-key", token: envKey, fingerprintInput: envKey };
+    }
+    if (process.platform === "darwin") {
+        const raw = await readMacKeychain();
+        if (raw) {
+            try {
+                const parsed = JSON.parse(raw);
+                const oauth = parsed?.claudeAiOauth ?? parsed;
+                if (oauth?.accessToken) {
+                    return {
+                        kind: "oauth",
+                        token: oauth.accessToken,
+                        fingerprintInput: oauth.accessToken,
+                    };
+                }
+            }
+            catch {
+                // fall through
+            }
+        }
+    }
+    // Linux/Windows fallback: look for ~/.claude/.credentials.json (best-effort).
+    try {
+        const raw = await readFile(join(homedir(), ".claude", ".credentials.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        const oauth = parsed?.claudeAiOauth ?? parsed;
+        if (oauth?.accessToken) {
+            return {
+                kind: "oauth",
+                token: oauth.accessToken,
+                fingerprintInput: oauth.accessToken,
+            };
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function readMacKeychain() {
+    return new Promise((resolve) => {
+        const user = process.env.USER ?? "";
+        const proc = spawn("security", ["find-generic-password", "-a", user, "-s", "Claude Code-credentials", "-w"], { stdio: ["ignore", "pipe", "pipe"] });
+        let out = "";
+        proc.stdout.on("data", (b) => (out += b.toString()));
+        proc.on("error", () => resolve(null));
+        proc.on("close", (code) => resolve(code === 0 ? out.trim() : null));
+    });
+}
+function utilizationToWindow(map, prefix) {
+    const util = num(map, `${prefix}-utilization`);
+    if (util === undefined)
+        return undefined;
+    const usedPercent = Math.max(0, Math.min(100, util * 100));
+    return {
+        usedPercent,
+        remainingPercent: 100 - usedPercent,
+        resetAt: num(map, `${prefix}-reset`),
+        status: str(map, `${prefix}-status`),
+    };
+}
+function parseClaudeHeaders(map) {
+    const fiveHour = utilizationToWindow(map, "anthropic-ratelimit-unified-5h") ?? {
+        usedPercent: 0,
+        remainingPercent: 0,
+    };
+    const weekly = utilizationToWindow(map, "anthropic-ratelimit-unified-7d") ?? {
+        usedPercent: 0,
+        remainingPercent: 0,
+    };
+    const weeklySonnet = utilizationToWindow(map, "anthropic-ratelimit-unified-7d_sonnet");
+    return {
+        overallStatus: str(map, "anthropic-ratelimit-unified-status"),
+        fiveHour,
+        weekly,
+        weeklySonnet,
+        overage: {
+            status: str(map, "anthropic-ratelimit-unified-overage-status"),
+            disabledReason: str(map, "anthropic-ratelimit-unified-overage-disabled-reason"),
+        },
+        raw: Object.fromEntries(Object.entries(map).filter(([k]) => k.startsWith("anthropic-ratelimit-"))),
+    };
+}
+export async function getClaudeQuota(opts = {}) {
+    const ttl = opts.ttlSeconds ?? DEFAULT_TTL;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const credential = opts.credential ?? (await resolveClaudeCredential());
+    if (!credential) {
+        return emptyQuota("unknown", "no Claude credential found (ANTHROPIC_API_KEY env, macOS Keychain, or ~/.claude/.credentials.json)");
+    }
+    const fp = fingerprintKey(["claude", credential.kind, credential.fingerprintInput.slice(0, 32)]);
+    const file = cacheFile("claude", fp, opts.cacheDir);
+    if (!opts.forceRefresh && ttl > 0) {
+        const cached = await readCache(file);
+        if (isFresh(cached, ttl) && cached) {
+            return { ...cached.value, source: "cached" };
+        }
+    }
+    const isOauth = credential.kind === "oauth";
+    const headers = {
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json",
+    };
+    if (isOauth) {
+        headers["authorization"] = `Bearer ${credential.token}`;
+        headers["anthropic-beta"] = "oauth-2025-04-20";
+        headers["user-agent"] = "claude-cli/1.0.128 (external, cli)";
+        headers["x-app"] = "cli";
+    }
+    else {
+        headers["x-api-key"] = credential.token;
+    }
+    const body = {
+        model: opts.model ?? "claude-sonnet-4-5",
+        max_tokens: 1,
+        messages: [{ role: "user", content: "hi" }],
+    };
+    if (isOauth) {
+        body.system = [{ type: "text", text: CLAUDE_CODE_SYSTEM_PROMPT }];
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+        res = await fetch(MESSAGES_URL, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        clearTimeout(timer);
+        return await fallbackFromCache(file, ttl, err?.message ?? String(err));
+    }
+    clearTimeout(timer);
+    try {
+        await res.body?.cancel();
+    }
+    catch {
+        // ignore
+    }
+    const map = headersToMap(res.headers);
+    if ((res.status === 401 || res.status === 403) && !Object.keys(map).some((k) => k.startsWith("anthropic-ratelimit-"))) {
+        return await fallbackFromCache(file, ttl, `auth failed: HTTP ${res.status}`);
+    }
+    const parsed = parseClaudeHeaders(map);
+    const fresh = {
+        tool: "claude",
+        fetchedAt: Math.floor(Date.now() / 1000),
+        source: "fresh",
+        ...parsed,
+    };
+    if (Object.keys(fresh.raw ?? {}).length > 0) {
+        await writeCache(file, fresh);
+        return fresh;
+    }
+    return await fallbackFromCache(file, ttl, `no anthropic-ratelimit-* headers on HTTP ${res.status}`);
+}
+async function fallbackFromCache(file, ttl, error) {
+    const cached = await readCache(file);
+    if (cached) {
+        return {
+            ...cached.value,
+            source: isFresh(cached, ttl) ? "cached" : "stale",
+            error,
+        };
+    }
+    return emptyQuota("unknown", error);
+}
+function emptyQuota(source, error) {
+    return {
+        tool: "claude",
+        source,
+        error,
+        fetchedAt: Math.floor(Date.now() / 1000),
+        fiveHour: { usedPercent: 0, remainingPercent: 0 },
+        weekly: { usedPercent: 0, remainingPercent: 0 },
+    };
+}

package/dist/manager/quota/codex.d.ts

@@ -0,0 +1,27 @@
+import type { CodexQuota } from "../types.js";
+export interface GetCodexQuotaOptions {
+    codexAuthPath?: string;
+    /** Cache TTL in seconds. Default 60. Pass 0 to always bypass cache. */
+    ttlSeconds?: number;
+    /** If true, ignore cache and refetch. */
+    forceRefresh?: boolean;
+    /** Request timeout in ms. */
+    timeoutMs?: number;
+    /** Model name; defaults to the one in ~/.codex/config.toml, then `gpt-5`. */
+    model?: string;
+    /** Override path to codex config.toml (to detect model). */
+    codexConfigPath?: string;
+    /** Override cache directory (mainly for tests). */
+    cacheDir?: string;
+}
+export declare function getCodexQuota(opts?: GetCodexQuotaOptions): Promise<CodexQuota>;
+/**
+ * Read the on-disk quota cache for a given codex auth.json without triggering
+ * any network call. Returns whatever snapshot was last written (regardless of
+ * age) or `null` if nothing has been cached for this identity yet. Used by the
+ * daemon's `list_accounts` handler to surface "last known" quota for inactive
+ * accounts so the web UI can restore them across page refreshes.
+ */
+export declare function readCachedCodexQuota(codexAuthPath: string, opts?: {
+    cacheDir?: string;
+}): Promise<CodexQuota | null>;