@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
158 lines (143 loc) • 8.24 kB
text/typescript
/**
* Activation owner for JEV advisory quota evidence.
*
* The decision snapshot (`src/providers/quota-decision-snapshot.ts`) is imported here and by
* nothing on the core path. Core credential stores and quota producers call the slot in
* `src/lib/decision-quota-sink.ts`; this module registers the snapshot-backed sink only while the
* live config has a JEV combo with `decisionQuotaSignals: true`, and withdraws everything when the
* last such combo is turned off, deleted or the config root changes.
*
* Activation replays the current stores through observe-only reads (`peekAuthStore`,
* `peekCodexAccountRecordStore`, `peekMainDecisionRow`): no hardening, backup, write, credential
* resolution or upstream probe, and never on a request's decision path. Stores keep no in-memory
* cache, so this one bounded read at activation is what "publish once from the loaded stores" costs,
* paid only by installs that opted in.
*/
import {
clearDecisionAccountQuotas, invalidateDecisionKeyQuotas, observeDecisionKeyCredential, publishDecisionAccountQuota,
publishDecisionKeyQuota, publishDecisionQuotaRoster, readLoadedDecisionKeyQuota, readLoadedDecisionQuotaPool, replaceDecisionKeyQuotas,
setDecisionAccountUsable, withdrawDecisionQuotaRoster,
} from "../providers/quota-decision-snapshot";
import { captureAntigravityReceipt, observeAntigravityQuotaStore, replaceAntigravityQuotas } from "../providers/quota-decision-antigravity";
import { registerDecisionQuotaSink, type DecisionQuotaSink, type MainDecisionRow } from "../lib/decision-quota-sink";
import { registerLiveConfigObserver } from "../lib/state-store-registrations";
import { getConfigDir } from "../config/paths";
import { peekAuthStore } from "../oauth/store";
import { peekCodexAccountRecordStore } from "../codex/account-store";
import { peekMainDecisionRow } from "../codex/main-account-cache";
import { createHash } from "node:crypto";
import type { AuthStore } from "../oauth/store";
import type { CodexAccountCredentialRecord, OcxConfig } from "../types";
const POOL_PROVIDERS = ["anthropic", "codex", "codex-main"] as const;
/** Project an auth store the owner already read into the secret-free Anthropic roster (primary pool only); a failure withdraws so the pool reads as unknown. The generation is a one-way digest of the credential, never the credential itself. */
function publishAuthDecisionQuotaRoster(store: AuthStore): void {
observeAntigravityQuotaStore(store);
try {
publishDecisionQuotaRoster("anthropic", (store.anthropic?.accounts ?? []).map(row => ({
id: row.id,
generation: createHash("sha256").update(JSON.stringify([row.credential.refresh, row.credential.access, row.credential.expires])).digest("hex"),
usable: row.paused !== true && row.needsReauth !== true && Boolean(row.credential.access || row.credential.refresh),
})));
} catch {
try { withdrawDecisionQuotaRoster("anthropic"); } catch { /* unknown */ }
}
}
/** Project a Codex account store the owner already read into the secret-free roster (id, credential generation, usability); a failure withdraws. */
function publishCodexDecisionQuotaRoster(store: Readonly<Record<string, CodexAccountCredentialRecord>>): void {
try {
publishDecisionQuotaRoster("codex", Object.entries(store).map(([id, row]) => ({
id, generation: row.generation,
usable: !!row.credential && row.deletedAt == null && !row.codexValidationPending && !row.lastCodexValidationTerminal,
})));
} catch {
try { withdrawDecisionQuotaRoster("codex"); } catch { /* unknown */ }
}
}
/** Whether a config enables advisory quota signals on at least one JEV combo. */
export function jevQuotaSignalsWanted(config: Pick<OcxConfig, "combos"> | null | undefined): boolean {
return Object.values(config?.combos ?? {}).some(combo => combo?.strategy === "jev" && combo.decisionQuotaSignals === true);
}
/** Publish the native-main row, or withdraw it; a failed publication withdraws so a previous row cannot linger (same guard as the auth/Codex projections). */
function publishMainRow(row: MainDecisionRow | undefined): void {
try {
if (row) publishDecisionQuotaRoster("codex-main", [{ id: "__main__", generation: row.generation, usable: row.usable }]);
else withdrawDecisionQuotaRoster("codex-main");
} catch {
try { withdrawDecisionQuotaRoster("codex-main"); } catch { /* best-effort; the pool reads as unknown */ }
}
}
const snapshotSink: DecisionQuotaSink = {
observeKeyCredential: observeDecisionKeyCredential,
invalidateKeyQuotas: invalidateDecisionKeyQuotas,
publishKeyQuota: publishDecisionKeyQuota,
publishAccountQuota: (provider, id, generation, windows, partial) => publishDecisionAccountQuota(provider, id, generation, windows, partial),
setAccountUsable: setDecisionAccountUsable,
clearAccountQuotas: clearDecisionAccountQuotas,
authStoreLoaded: publishAuthDecisionQuotaRoster,
codexStoreLoaded: publishCodexDecisionQuotaRoster,
mainRosterChanged: row => publishMainRow(row),
readKeyQuota: readLoadedDecisionKeyQuota,
readPool: readLoadedDecisionQuotaPool,
captureAntigravityReceipt,
replaceCollectedQuotas: (keys, oauth) => { replaceDecisionKeyQuotas(keys); replaceAntigravityQuotas(oauth); },
};
let active: { detach: () => void; root: string } | undefined;
function withdrawAll(): void {
for (const provider of POOL_PROVIDERS) withdrawDecisionQuotaRoster(provider);
clearDecisionAccountQuotas();
invalidateDecisionKeyQuotas();
}
/**
* Replay the current stores into the snapshot through observe-only reads. Each pool fails closed to
* unknown. Ownership is rechecked after every read: a reentrant notification that deactivates (or
* restarts) during a read must not be followed by a publication from this stale replay.
*/
function replayCurrentStores(owner: object): void {
const owns = () => active === owner;
try { const store = peekAuthStore(); if (owns()) publishAuthDecisionQuotaRoster(store); } catch { if (owns()) withdrawDecisionQuotaRoster("anthropic"); }
try { const store = peekCodexAccountRecordStore(); if (owns()) publishCodexDecisionQuotaRoster(store); } catch { if (owns()) withdrawDecisionQuotaRoster("codex"); }
try { const row = peekMainDecisionRow(); if (owns()) publishMainRow(row); } catch { if (owns()) { try { withdrawDecisionQuotaRoster("codex-main"); } catch { /* unknown */ } } }
}
/** Detach the sink first, so no producer can write while the snapshot is withdrawn. */
export function deactivateJevQuotaActivation(): void {
const current = active;
if (!current) return;
active = undefined;
current.detach();
try { withdrawAll(); } catch { /* the snapshot is unreachable once detached */ }
}
/** Converge activation with a live config: register on the first enabling combo, withdraw after the last, and restart on a config root change. Never throws. */
export function reconcileJevQuotaActivation(config: OcxConfig): void {
try {
const wanted = jevQuotaSignalsWanted(config);
const root = getConfigDir();
if (active && (!wanted || active.root !== root)) deactivateJevQuotaActivation();
if (!wanted || active) return;
const owner = { detach: registerDecisionQuotaSink(snapshotSink), root };
active = owner;
replayCurrentStores(owner);
} catch {
deactivateJevQuotaActivation();
}
}
/** Whether the snapshot-backed sink is currently registered by this owner. */
export function jevQuotaActivationActive(): boolean { return active !== undefined; }
let stopCurrent: (() => void) | undefined;
/**
* Live-owner lifecycle, started by the server's optional-subsystem set once it is serving.
* Registers the live-config observer and reconciles once with the start-time config; the returned
* stop unregisters and deactivates. A second start replaces the first.
*/
export function startJevQuotaActivation(config: OcxConfig): () => void {
stopCurrent?.();
const unregister = registerLiveConfigObserver("jev-quota-activation", reconcileJevQuotaActivation);
const stop = () => {
if (stopCurrent !== stop) return;
stopCurrent = undefined;
unregister();
deactivateJevQuotaActivation();
};
stopCurrent = stop;
reconcileJevQuotaActivation(config);
return stop;
}