UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

249 lines (234 loc) • 13.4 kB
import { createHash } from "node:crypto"; import { readFileSync } from "node:fs"; import { homedir } from "node:os"; import { join } from "node:path"; import { isTestHomeGuardArmed } from "../../lib/test-home-guard"; import { detectClaudeCodeTokenAsync } from "../../oauth/local-token-detect"; import { readClaudeCliUsageQuota } from "../../providers/claude-cli-usage"; import { claudeUsageStatePath, loadClaudeUsageSnapshot, readClaudeUsageSnapshots, recordClaudeSignedInIdentity, saveClaudeUsageSnapshot, type ClaudeUsageSnapshot, } from "../../providers/claude-cli-usage-state"; import type { ProviderQuota } from "../../providers/quota-types"; export type ClaudeAdmission = { state: "available" | "exhausted" | "unknown"; checkedAt: number; resetAt?: number; message?: string; }; type Identity = { key: string; access: string }; export type AdmissionDeps = { now?: () => number; /** Resolve the signed-in account. `fresh` bypasses the short in-memory identity cache. */ identity?: (fresh?: boolean) => Identity | null | Promise<Identity | null>; probe?: (token: string) => Promise<ProviderQuota | null>; statePath?: string; }; const CACHE_MS = 60_000; const inflight = new Map<string, Promise<ClaudeUsageSnapshot | null>>(); let identityCache: { scope: string; at: number; value: Promise<Identity | null> } | undefined; let identityOverride: ((fresh?: boolean) => Identity | null | Promise<Identity | null>) | undefined; let identityReads = 0; let recordedIdentityRead = 0; const nonEmpty = (value: unknown): value is string => typeof value === "string" && value.trim().length > 0; async function readLocalIdentity(): Promise<Identity | null> { // A test process never reads the operator's real sign-in or spends it on a usage probe; // tests that exercise admission inject `deps.identity`. if (isTestHomeGuardArmed()) return null; const credential = await detectClaudeCodeTokenAsync(); if (!credential || !nonEmpty(credential.access)) return null; let account: unknown; try { const configDir = process.env.CLAUDE_CONFIG_DIR?.trim(); const configFile = configDir ? join(configDir, ".claude.json") : join(homedir(), ".claude.json"); account = JSON.parse(readFileSync(configFile, "utf8"))?.oauthAccount?.accountUuid; } catch { /* Token fingerprint is the fallback when CLI has no account metadata. */ } const seed = nonEmpty(account) ? account : nonEmpty(credential.refresh) ? credential.refresh : undefined; if (!seed) return null; return { key: createHash("sha256").update(seed).digest("hex"), access: credential.access }; } /** * The signed-in Claude Code account, read through the CLI's own secure storage. Cached briefly so * a burst of turns costs one Keychain lookup; an account switch is noticed within the cache window. * Every read is recorded, newest read wins, so a published quota row can tell it was superseded. */ function localIdentity(fresh = false): Promise<Identity | null> { const scope = process.env.CLAUDE_CONFIG_DIR?.trim() ?? ""; const now = Date.now(); if (!fresh && identityCache && identityCache.scope === scope && now - identityCache.at < CACHE_MS) return identityCache.value; const read = ++identityReads; const override = identityOverride; const value = (override ? Promise.resolve().then(() => override(fresh)) : readLocalIdentity()) .catch(() => null) .then(identity => { if (read > recordedIdentityRead) { recordedIdentityRead = read; recordClaudeSignedInIdentity(identity?.key ?? null); } return identity; }); identityCache = { scope, at: now, value }; return value; } /** Test seam for the signed-in account; call with no argument to restore the real sign-in read. */ export function setClaudeIdentityForTests(fn?: (fresh?: boolean) => Identity | null | Promise<Identity | null>): void { identityOverride = fn; identityCache = undefined; recordClaudeSignedInIdentity(null); } /** * The signed-in account's hashed key, or null when signed out or the sign-in cannot be read. Only * the key leaves this module, never the access token. `fresh` bypasses the identity cache. */ export async function currentClaudeIdentityKey(fresh = false): Promise<string | null> { return (await resolveIdentity({}, fresh))?.key ?? null; } async function resolveIdentity(deps: AdmissionDeps, fresh = false): Promise<Identity | null> { try { return await (deps.identity ?? localIdentity)(fresh); } catch { return null; } } function finite(value: unknown): value is number { return typeof value === "number" && Number.isFinite(value); } /** Windows that gate this model: the plan windows plus custom windows in scope for its family. */ function applicableWindows(quota: ProviderQuota | undefined, model: string): { percent?: number; resetAt?: number }[] { const family = /opus|sonnet|fable|haiku/i.exec(model)?.[0]?.toLowerCase(); return [ { percent: quota?.fiveHourPercent, resetAt: quota?.fiveHourResetAt }, { percent: quota?.weeklyPercent, resetAt: quota?.weeklyResetAt }, ...(quota?.customWindows ?? []).filter(w => w.scope !== "model" || !family || w.label.toLowerCase() === family), ]; } /** A reset time in the proxy host's own time zone (or the given one), with the zone named. */ export function formatClaudeReset(resetAt: number, timeZone?: string): string { return new Intl.DateTimeFormat("en-US", { ...(timeZone ? { timeZone } : {}), month: "short", day: "numeric", hour: "numeric", minute: "2-digit", timeZoneName: "short", }).format(resetAt); } function full(w: { percent?: number }): boolean { return finite(w.percent) && w.percent >= 100; } function admission(snapshot: ClaudeUsageSnapshot, model: string, now: number): ClaudeAdmission { const quota = snapshot.quota; const planExhausted = applicableWindows(quota, model).filter(w => full(w) && (!finite(w.resetAt) || w.resetAt > now)); const extraEnabled = quota?.claudeExtraUsage === "enabled"; const exhausted = extraEnabled ? [] : planExhausted; if (finite(snapshot.refusalUntil) && snapshot.refusalUntil > now) exhausted.push({ percent: 100, resetAt: snapshot.refusalUntil }); if (exhausted.length) { const resets = exhausted.map(w => w.resetAt).filter(finite); // Unknown reset windows require another read after the short cache, not an invented reset date. const resetAt = resets.length === exhausted.length ? Math.max(...resets) : Math.max(snapshot.checkedAt + CACHE_MS, ...resets); return { state: "exhausted", checkedAt: snapshot.checkedAt, resetAt, message: `Claude subscription limits are exhausted. Claude launches are paused until ${formatClaudeReset(resetAt)}, then usage will be checked again.` }; } // Extra usage can outlive plan windows; the CLI still enforces the wallet and spend limit. return { state: quota && !(extraEnabled && planExhausted.length) ? "available" : "unknown", checkedAt: snapshot.checkedAt }; } /** * Read-only quota preflight for a `claude-cli` launch. Fails open: any local or upstream failure * reports `unknown`, which admits the turn and lets the CLI report its own limit. */ export async function checkClaudeUsageAdmission(model = "", deps: AdmissionDeps = {}): Promise<ClaudeAdmission> { const now = (deps.now ?? Date.now)(); try { return await checkAdmission(model, deps, now); } catch { return { state: "unknown", checkedAt: now }; } } async function checkAdmission(model: string, deps: AdmissionDeps, now: number): Promise<ClaudeAdmission> { const identity = await resolveIdentity(deps); if (!identity) return { state: "unknown", checkedAt: now }; const path = claudeUsageStatePath(deps.statePath); const cached = readClaudeUsageSnapshots(path) .filter(s => s.identity === identity.key) .sort((a, b) => b.checkedAt - a.checkedAt || (b.refusalUntil ?? 0) - (a.refusalUntil ?? 0))[0]; if (cached) { const status = admission(cached, model, now); if (finite(cached.refusalUntil) && cached.refusalUntil > now) return status; // Refresh early when a recorded refusal or full in-scope window resets after this reading. const crossedReset = [cached.refusalUntil, ...applicableWindows(cached.quota, model).filter(full).map(w => w.resetAt)] .some(reset => finite(reset) && cached.checkedAt < reset && reset <= now); if (!crossedReset && now >= cached.checkedAt && now - cached.checkedAt < CACHE_MS) return status; } const requestKey = `${path}:${identity.key}`; let probe = inflight.get(requestKey); if (!probe) { probe = (async () => { let quota: ProviderQuota | null = null; try { quota = await (deps.probe ?? readClaudeCliUsageQuota)(identity.access); } catch { /* Unavailable is unknown. */ } // A login change during the probe makes this answer belong to no current account: neither // persist it nor admit or refuse with it. if ((await resolveIdentity(deps, true))?.key !== identity.key) return null; // Merge the newest refusal at commit time. Nothing awaits between this read and the write, // so a refusal the CLI reported while the probe was in flight is never overwritten. const at = (deps.now ?? Date.now)(); const refusals = readClaudeUsageSnapshots(path) .filter(s => s.identity === identity.key) .map(s => s.refusalUntil) .filter((until): until is number => finite(until) && until > at); const refusalUntil = refusals.length ? Math.max(...refusals) : undefined; const snapshot: ClaudeUsageSnapshot = { identity: identity.key, checkedAt: at, ...(quota ? { quota } : {}), ...(refusalUntil ? { refusalUntil } : {}) }; saveClaudeUsageSnapshot(path, snapshot); return snapshot; })().finally(() => inflight.delete(requestKey)); inflight.set(requestKey, probe); } const snapshot = await probe; if (!snapshot) return { state: "unknown", checkedAt: (deps.now ?? Date.now)() }; return admission(snapshot, model, (deps.now ?? Date.now)()); } let preflightOverride: ((model: string) => Promise<ClaudeAdmission>) | undefined; /** Test seam for the pre-dispatch check in the Responses executor; call with no argument to restore. */ export function setClaudeUsagePreflightForTests(fn?: (model: string) => Promise<ClaudeAdmission>): void { preflightOverride = fn; } /** The pre-dispatch check the Responses executor runs before a claude-cli turn. */ export function claudeUsagePreflight(model: string): Promise<ClaudeAdmission> { return (preflightOverride ?? checkClaudeUsageAdmission)(model); } // Claude prints "resets 3pm (Europe/Paris)" or "resets 3:30pm (...)"; minutes are optional. const CLAUDE_RESET_CLOCK = /resets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(([^)]+)\)/i; /** * Whether text carries the reset-clock wording the refusal parser honors. The check is lexical * only — no "limit" keyword and no clock resolution against the current time — because the phrase * matters wherever it appears: a caller-controlled model id can carry the clock while the CLI's * own error wording supplies the limit keyword around it. */ export function containsClaudeResetClock(text: string): boolean { return CLAUDE_RESET_CLOCK.test(text); } /** Parse Claude's explicit next-clock reset, including its IANA timezone. */ export function parseClaudeReset(message: string, now = Date.now()): number | undefined { if (!/hit.*limit|usage limit|rate limit/i.test(message)) return; const match = CLAUDE_RESET_CLOCK.exec(message); if (!match) return; const hour = Number(match[1]); const minute = Number(match[2] ?? 0); if (hour < 1 || hour > 12 || minute > 59) return; const hours = hour % 12 + (match[3]!.toLowerCase() === "pm" ? 12 : 0); try { const formatter = new Intl.DateTimeFormat("en-US", { timeZone: match[4], year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", second: "2-digit", hourCycle: "h23" }); const parts = (time: number) => Object.fromEntries(formatter.formatToParts(time).filter(p => p.type !== "literal").map(p => [p.type, Number(p.value)])); const date = parts(now); for (let day = 0; day < 2; day++) { const target = Date.UTC(date.year!, date.month! - 1, date.day! + day, hours, minute); let epoch = target; for (let i = 0; i < 3; i++) { const p = parts(epoch); epoch += target - Date.UTC(p.year!, p.month! - 1, p.day!, p.hour!, p.minute!, p.second!); } if (epoch > now && epoch - now <= 26 * 60 * 60_000) return epoch; } } catch { /* An invalid or unsupported timezone never establishes a cooldown. */ } } /** * Remember a limit the CLI itself reported ("You've hit your limit · resets 3pm (Europe/Paris)") * so later launches are refused locally until that reset. Only a parsed reset records anything. */ export async function recordClaudeUsageRefusal(message: string, deps: AdmissionDeps = {}): Promise<void> { const now = (deps.now ?? Date.now)(); const until = parseClaudeReset(message, now); if (!until) return; const identity = await resolveIdentity(deps); if (!identity) return; const path = claudeUsageStatePath(deps.statePath); const old = loadClaudeUsageSnapshot(path); const same = old?.identity === identity.key ? old : undefined; saveClaudeUsageSnapshot(path, { identity: identity.key, checkedAt: now, ...(same?.quota ? { quota: same.quota } : {}), refusalUntil: Math.max(until, same?.refusalUntil ?? 0) }); }