UNPKG

@bitkyc08/opencodex

Version:

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

236 lines (204 loc) • 11.6 kB
import { getConfigDir } from "../config/paths"; import { notifyMainRosterChanged, type MainDecisionRow } from "../lib/decision-quota-sink"; import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto"; import { codexCredentialMutationEpoch } from "./credential-mutation-epoch"; import type { StoredAccountQuota } from "./quota-types"; import { truncateRetainedUtf8 } from "../lib/admission"; const MAX_DIAGNOSTIC_VALUE_BYTES = 8 * 1024; export interface MainAccountInfo { email: string | null; plan: string | null; quota: Omit<StoredAccountQuota, "updatedAt"> | null; } export interface CachedMainAccountInfo extends MainAccountInfo { ts: number; } let cachedMainAccountInfo: CachedMainAccountInfo | null = null; let cachedMainCredentialPresence: boolean | null = null; let mainAccountIdentityGeneration = 0; let observedMainQuotaIdentityKey: string | undefined; const mainQuotaCredentialKey = randomBytes(32); let mainQuotaCredential: { bearerHmac: Buffer; writer: MainQuotaWriter } | undefined; let mainQuotaCredentialGeneration = 0; let mainDecisionCredentialUsable = true; // Advisory-only generation for the decision row and its writers. It follows every core credential // generation change and additionally advances when physical presence is lost, so absence retires // advisory evidence without touching the core credential binding that policy checks rely on. let mainDecisionGeneration = 0; // Advisory-only: the retained credential was re-observed since presence was last lost. Absence and // presence-forgetting clear it, so the decision row stays unusable until a fresh owned observation. let mainDecisionCredentialFresh = false; // Config root that owns the observed main identity/credential for advisory decision evidence only. // Stamped at identity/credential observations while a sink is active; other transitions never claim a root. let mainDecisionRoot: string | undefined; /** Existing physical credential owner supplies terminal grant/usability observations. */ export function observeMainDecisionCredentialUsable(usable: boolean): void { mainDecisionCredentialUsable = usable; publishMainDecisionRoster(); } /** Process-local transition fence; no credential material or persisted identity. */ export function getMainQuotaCredentialGeneration(): number { return mainQuotaCredentialGeneration; } export type MainQuotaWriter = Readonly<{ identityKey: string; identityGeneration: number }>; const decisionWriterGenerations = new WeakMap<MainQuotaWriter, number>(); /** Return the credential generation a main quota writer was captured under, or undefined once that writer is stale or its credential generation has moved. */ export function mainDecisionQuotaWriterGeneration(writer: MainQuotaWriter): number | undefined { const generation = decisionWriterGenerations.get(writer); return generation === mainDecisionGeneration && isMainQuotaWriterLive(writer) && mainDecisionRoot === getConfigDir() ? generation : undefined; } function mainQuotaIdentityKey(accountId: string): string { return createHash("sha256").update("opencodex-main-quota-v1\0").update(accountId).digest("hex"); } /** Only an existing owned physical-identity read may publish this observation. */ export function observeMainQuotaIdentity(accountId: string): void { if (!accountId) return; const identityKey = mainQuotaIdentityKey(accountId); if (identityKey === observedMainQuotaIdentityKey) return; observedMainQuotaIdentityKey = identityKey; mainDecisionCredentialUsable = true; mainAccountIdentityGeneration += 1; mainQuotaCredential = undefined; mainQuotaCredentialGeneration += 1; mainDecisionGeneration += 1; publishMainDecisionRoster(true); } /** Capture a main quota writer for an account id only when it matches the observed physical identity, remembering the credential generation it was captured under. */ export function captureMainQuotaWriter(accountId: string): MainQuotaWriter | undefined { if (!accountId) return undefined; const identityKey = mainQuotaIdentityKey(accountId); if (identityKey !== observedMainQuotaIdentityKey) return undefined; const writer = { identityKey, identityGeneration: mainAccountIdentityGeneration }; if (mainQuotaCredential) decisionWriterGenerations.set(writer, mainDecisionGeneration); return writer; } /** Credential material must come from an already-owned read, never an incoming request. */ export function observeMainQuotaCredential(accessToken: string, accountId: string): MainQuotaWriter | undefined { const writer = captureMainQuotaWriter(accountId); if (!accessToken || !writer) return undefined; const bearerHmac = createHmac("sha256", mainQuotaCredentialKey).update(accessToken).digest(); if (!mainQuotaCredential || !isMainQuotaWriterLive(mainQuotaCredential.writer) || !timingSafeEqual(bearerHmac, mainQuotaCredential.bearerHmac)) { mainQuotaCredentialGeneration += 1; mainDecisionGeneration += 1; } mainQuotaCredential = { bearerHmac, writer }; mainDecisionCredentialFresh = true; publishMainDecisionRoster(true); const result = { ...writer }; decisionWriterGenerations.set(result, mainDecisionGeneration); return result; } export function matchesMainQuotaCredential(accessToken: string, effectiveAccountId: string | undefined): boolean { const observed = mainQuotaCredential; if (!accessToken || !effectiveAccountId || !observed || !isMainQuotaWriterLive(observed.writer)) return false; if (mainQuotaIdentityKey(effectiveAccountId) !== observed.writer.identityKey) return false; const candidate = createHmac("sha256", mainQuotaCredentialKey).update(accessToken).digest(); return timingSafeEqual(candidate, observed.bearerHmac); } export function isMainQuotaWriterLive(writer: MainQuotaWriter): boolean { return writer.identityKey === observedMainQuotaIdentityKey && writer.identityGeneration === mainAccountIdentityGeneration; } /** Proof that a dispatch used the observed main credential; process-local, never persisted. */ export type MainQuotaDispatch = Readonly<{ writer: MainQuotaWriter; credentialGeneration: number; credentialMutationEpoch: number; configGeneration: number; }>; // WS quota frames publish through their observer; prelude quota can only come from those frames. // A real HTTP fallback after a failed upgrade never invokes the observer and stays unclaimed. const wsObservedMainDispatches = new WeakSet<MainQuotaDispatch>(); export function claimMainQuotaDispatchForWs(dispatch: MainQuotaDispatch): void { wsObservedMainDispatches.add(dispatch); } export function isMainQuotaDispatchWsClaimed(dispatch: MainQuotaDispatch): boolean { return wsObservedMainDispatches.has(dispatch); } /** Give a replacement physical attempt its own quota ownership without recapturing credential fences. */ export function renewMainQuotaDispatchForAttempt(dispatch: MainQuotaDispatch): MainQuotaDispatch { return { ...dispatch }; } export function captureMainQuotaDispatch( accessToken: string, accountId: string | undefined, configGeneration: number, ): MainQuotaDispatch | undefined { if (!accountId || !matchesMainQuotaCredential(accessToken, accountId)) return undefined; const writer = captureMainQuotaWriter(accountId); return writer ? { writer, credentialGeneration: mainQuotaCredentialGeneration, credentialMutationEpoch: codexCredentialMutationEpoch(), configGeneration } : undefined; } export function isMainQuotaDispatchLive(dispatch: MainQuotaDispatch): boolean { // Other OpenCodex-owned credential publications also advance this epoch; // dropping a main quota update after any such publication is the intended safe direction. return isMainQuotaWriterLive(dispatch.writer) && dispatch.credentialGeneration === mainQuotaCredentialGeneration && dispatch.credentialMutationEpoch === codexCredentialMutationEpoch(); } export function getObservedMainQuotaIdentityKey(): string | undefined { return observedMainQuotaIdentityKey; } export function captureMainAccountIdentityGeneration(): number { return mainAccountIdentityGeneration; } export function isMainAccountIdentityGenerationLive(generation: number): boolean { return generation === mainAccountIdentityGeneration; } export function getMainAccountInfoCache(): CachedMainAccountInfo | null { return cachedMainAccountInfo; } export function setMainAccountInfoCache(value: CachedMainAccountInfo): void { cachedMainAccountInfo = { ...value, email: value.email === null ? null : truncateRetainedUtf8(value.email, MAX_DIAGNOSTIC_VALUE_BYTES), plan: value.plan === null ? null : truncateRetainedUtf8(value.plan, MAX_DIAGNOSTIC_VALUE_BYTES), }; } /** Drop the cached main-account info and invalidate the observed identity and credential generation, then republish the main decision roster as unusable. */ export function clearMainAccountInfoCache(): void { cachedMainAccountInfo = null; mainAccountIdentityGeneration += 1; mainQuotaCredential = undefined; mainQuotaCredentialGeneration += 1; mainDecisionGeneration += 1; publishMainDecisionRoster(); } /** Last physical credential presence observed while native-main ownership was held. */ export function getMainAccountCredentialPresence(): boolean | null { return cachedMainCredentialPresence; } /** Record whether the main credential is physically present. The core credential binding is left intact (a failed read must not change policy matching); losing presence only retires advisory decision evidence. */ export function setMainAccountCredentialPresence(present: boolean): void { if (!present && cachedMainCredentialPresence !== false) { mainDecisionGeneration += 1; mainDecisionCredentialFresh = false; } cachedMainCredentialPresence = present; publishMainDecisionRoster(); } /** Forget the last observed main credential presence; retires advisory decision evidence only, leaving the core credential binding intact. */ export function clearMainAccountCredentialPresence(): void { cachedMainCredentialPresence = null; mainDecisionGeneration += 1; mainDecisionCredentialFresh = false; publishMainDecisionRoster(); } /** * Build the single `__main__` decision row from in-memory fields. With no retained credential the * row is a known-unusable main (nothing to misattribute), as before. A retained credential counts only * for the config root that observed it: for any other root the row is undefined (unknown) and the * claimed root is forgotten, so returning to the old root never resurrects it without a new owned * observation. */ function mainDecisionRow(): MainDecisionRow | undefined { if (mainQuotaCredential === undefined) return { generation: mainDecisionGeneration, usable: false }; if (mainDecisionRoot === undefined || mainDecisionRoot !== getConfigDir()) { mainDecisionRoot = undefined; return undefined; } return { generation: mainDecisionGeneration, usable: mainDecisionCredentialFresh && mainDecisionCredentialUsable && cachedMainCredentialPresence !== false }; } /** Hand the main decision row to the opt-in decision-quota slot (a no-op unless JEV quota signals are active); identity/credential observations claim the current root. */ function publishMainDecisionRoster(claimsRoot = false): void { notifyMainRosterChanged(() => { if (claimsRoot) mainDecisionRoot = getConfigDir(); return mainDecisionRow(); }); } /** Activation replay for the JEV quota owner: the current row, or undefined when the observed credential belongs to another config root. */ export function peekMainDecisionRow(): MainDecisionRow | undefined { return mainDecisionRow(); }