@love-moon/ai-sdk 0.3.2 → 0.4.0

package/dist/manager/quota/codex.js

@@ -0,0 +1,182 @@
+import { readFile } from "node:fs/promises";
+import { parseAuthFile } from "../auth-parser.js";
+import { DEFAULT_CODEX_AUTH, DEFAULT_CODEX_CONFIG } from "../paths.js";
+import { bool, headersToMap, num, str } from "./headers.js";
+import { cacheFile, fingerprintKey, isFresh, readCache, writeCache } from "./cache.js";
+/** Best-effort: read the configured model from ~/.codex/config.toml. */
+async function readConfiguredModel(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        // Minimal top-level key scan: `model = "..."` (skip lines inside [tables]).
+        let inRootTable = true;
+        for (const line of raw.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("#") || trimmed === "")
+                continue;
+            if (/^\[/.test(trimmed)) {
+                inRootTable = false;
+                continue;
+            }
+            if (!inRootTable)
+                continue;
+            const m = /^model\s*=\s*"([^"]+)"/.exec(trimmed);
+            if (m)
+                return m[1];
+        }
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}
+const RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
+const DEFAULT_TTL = 60; // seconds
+const DEFAULT_TIMEOUT_MS = 15000;
+function windowFromHeaders(map, prefix) {
+    const usedPercent = num(map, `${prefix}-used-percent`) ?? 0;
+    return {
+        usedPercent,
+        remainingPercent: Math.max(0, 100 - usedPercent),
+        resetAfterSeconds: num(map, `${prefix}-reset-after-seconds`),
+        resetAt: num(map, `${prefix}-reset-at`),
+        windowMinutes: num(map, `${prefix}-window-minutes`),
+    };
+}
+function parseCodexHeaders(map, extras) {
+    return {
+        plan: str(map, "x-codex-plan-type"),
+        activeLimit: str(map, "x-codex-active-limit"),
+        fiveHour: windowFromHeaders(map, "x-codex-primary"),
+        weekly: windowFromHeaders(map, "x-codex-secondary"),
+        credits: {
+            hasCredits: bool(map, "x-codex-credits-has-credits") ?? false,
+            balance: str(map, "x-codex-credits-balance"),
+            unlimited: bool(map, "x-codex-credits-unlimited") ?? false,
+        },
+        email: extras.email,
+        accountId: extras.accountId,
+        raw: Object.fromEntries(Object.entries(map).filter(([k]) => k.startsWith("x-codex-"))),
+    };
+}
+export async function getCodexQuota(opts = {}) {
+    const codexAuthPath = opts.codexAuthPath ?? DEFAULT_CODEX_AUTH;
+    const ttl = opts.ttlSeconds ?? DEFAULT_TTL;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const authInfo = await parseAuthFile(codexAuthPath);
+    if (!authInfo.accessToken) {
+        return emptyQuota("unknown", "codex auth.json missing access_token");
+    }
+    const fp = fingerprintKey(["codex", authInfo.identityFingerprint ?? "unknown"]);
+    const file = cacheFile("codex", fp, opts.cacheDir);
+    if (!opts.forceRefresh && ttl > 0) {
+        const cached = await readCache(file);
+        if (isFresh(cached, ttl) && cached) {
+            return { ...cached.value, source: "cached" };
+        }
+    }
+    const model = opts.model ??
+        (await readConfiguredModel(opts.codexConfigPath ?? DEFAULT_CODEX_CONFIG)) ??
+        "gpt-5";
+    const body = JSON.stringify({
+        model,
+        instructions: "Reply with exactly one character.",
+        input: [
+            { type: "message", role: "user", content: [{ type: "input_text", text: "." }] },
+        ],
+        stream: true,
+        store: false,
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+        res = await fetch(RESPONSES_URL, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${authInfo.accessToken}`,
+                "Content-Type": "application/json",
+                "OpenAI-Beta": "responses=experimental",
+                ...(authInfo.accountId ? { "chatgpt-account-id": authInfo.accountId } : {}),
+            },
+            body,
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        clearTimeout(timer);
+        return await fallbackFromCache(file, ttl, err?.message ?? String(err));
+    }
+    // Abort the body stream immediately once headers are in; they're all we need.
+    try {
+        await res.body?.cancel();
+    }
+    catch {
+        // ignore
+    }
+    clearTimeout(timer);
+    const map = headersToMap(res.headers);
+    if (res.status === 401 || res.status === 403) {
+        return await fallbackFromCache(file, ttl, `auth failed: HTTP ${res.status}`);
+    }
+    const parsed = parseCodexHeaders(map, {
+        email: authInfo.email,
+        accountId: authInfo.accountId,
+    });
+    const now = Math.floor(Date.now() / 1000);
+    const fresh = {
+        tool: "codex",
+        fetchedAt: now,
+        source: "fresh",
+        ...parsed,
+    };
+    // Only persist if we actually got rate-limit headers — otherwise the upstream was unhealthy.
+    if (Object.keys(fresh.raw ?? {}).length > 0) {
+        await writeCache(file, fresh);
+        return fresh;
+    }
+    return await fallbackFromCache(file, ttl, `no x-codex-* 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);
+}
+/**
+ * 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 async function readCachedCodexQuota(codexAuthPath, opts = {}) {
+    try {
+        const authInfo = await parseAuthFile(codexAuthPath);
+        if (!authInfo.identityFingerprint)
+            return null;
+        const fp = fingerprintKey(["codex", authInfo.identityFingerprint]);
+        const file = cacheFile("codex", fp, opts.cacheDir);
+        const entry = await readCache(file);
+        if (!entry)
+            return null;
+        return { ...entry.value, source: "cached", fetchedAt: entry.fetchedAt };
+    }
+    catch {
+        return null;
+    }
+}
+function emptyQuota(source, error) {
+    return {
+        tool: "codex",
+        source,
+        error,
+        fetchedAt: Math.floor(Date.now() / 1000),
+        fiveHour: { usedPercent: 0, remainingPercent: 0 },
+        weekly: { usedPercent: 0, remainingPercent: 0 },
+    };
+}

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

@@ -0,0 +1,64 @@
+import type { CopilotClientOptions } from "@github/copilot-sdk";
+import type { CopilotQuota } from "../types.js";
+interface AccountGetQuotaResult {
+    quotaSnapshots?: Record<string, unknown>;
+}
+interface CopilotAuthStatus {
+    isAuthenticated: boolean;
+    authType?: string;
+    host?: string;
+    login?: string;
+    statusMessage?: string;
+}
+interface CopilotAuthInfo {
+    authType?: string;
+    host?: string;
+    login?: string;
+    loginSource?: "sdk" | "github_token";
+}
+interface CopilotClientLike {
+    start(): Promise<void>;
+    stop(): Promise<Error[]>;
+    forceStop?: () => Promise<void>;
+    getAuthStatus?: () => Promise<CopilotAuthStatus>;
+    rpc: {
+        account: {
+            getQuota(): Promise<AccountGetQuotaResult>;
+        };
+    };
+}
+interface CopilotSdkModule {
+    CopilotClient: new (options?: CopilotClientOptions) => CopilotClientLike;
+}
+interface ResolveBundledCopilotCliPathOptions {
+    platform?: NodeJS.Platform | string;
+    arch?: string;
+    resolvePackage?: (packageName: string) => string;
+    resolvePackagePaths?: (packageName: string) => string[] | null;
+    existsSyncFn?: (path: string) => boolean;
+}
+export interface GetCopilotQuotaOptions {
+    /** Cache TTL in seconds. Default 60. */
+    ttlSeconds?: number;
+    forceRefresh?: boolean;
+    /** Overall timeout for SDK start/auth/quota in ms. Cleanup has a separate small cap. */
+    timeoutMs?: number;
+    cacheDir?: string;
+    /** Explicit token to pass to the Copilot SDK; otherwise SDK auth discovery is used. */
+    githubToken?: string;
+    /** SDK client options. Useful for enterprise hosts or tests. */
+    clientOptions?: CopilotClientOptions;
+    /** Override global fetch for GitHub login lookup tests. */
+    fetcher?: typeof fetch;
+    /** Override SDK module for tests. */
+    sdkModule?: CopilotSdkModule;
+    /** Override stored-token lookup for Copilot logged-in users. */
+    storedTokenResolver?: (authInfo: CopilotAuthInfo | undefined) => Promise<string | undefined>;
+}
+export declare function getCopilotQuota(opts?: GetCopilotQuotaOptions): Promise<CopilotQuota>;
+export declare function resolveBundledCopilotCliPath({ platform, arch, resolvePackage, resolvePackagePaths, existsSyncFn, }?: ResolveBundledCopilotCliPathOptions): string | undefined;
+/** Exported for tests. */
+export declare function parseCopilotQuotaSnapshots(rawSnapshots: unknown): Omit<CopilotQuota, "tool" | "fetchedAt" | "source" | "error" | "login" | "authType" | "host" | "loginSource">;
+/** Exported for tests. */
+export declare function parseCopilotUserQuota(rawUser: unknown): Omit<CopilotQuota, "tool" | "fetchedAt" | "source" | "error" | "login" | "authType" | "host" | "loginSource">;
+export {};