@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
160 lines (158 loc) • 10.2 kB
text/typescript
import * as z from "zod/v4";
import { randomUUID } from "node:crypto";
import { readFileSync } from "node:fs";
import type { OcxConfig } from "../types";
import { isCanonicalAntigravityUrl } from "../lib/provider-tls-profile";
import { getConfigPath } from "./paths";
type PolicyConfig = { providers?: unknown; accountAutoPausePolicyRevisions?: unknown };
// fingerprint follows the live config; diskFingerprint follows the last observed disk state, so a
// detached load compares disk with disk and still fences an observed external policy change.
type Observed = { diskRevision: string; localGen: number; unknown: boolean; fingerprint: string; diskFingerprint: string };
export type AccountAutoPauseFence = { configPath: string; diskRevision: string; localGen: number; threshold: number; conclusiveOnly: boolean; route: string };
export type EffectiveAccountAutoPause = { threshold: number; conclusiveOnly: boolean };
const observed = new Map<string, Map<string, Observed>>();
// One process-wide allocator for every new entry and every advance: a deleted and recreated name
// can never reproduce an old {diskRevision, localGen} pair, even when both read "legacy".
let nextGeneration = 0;
const allocateGeneration = (): number => ++nextGeneration;
function hasProvider(config: PolicyConfig | undefined, name: string): boolean {
const providers = record(config?.providers);
return !!providers && Object.hasOwn(providers, name);
}
const UUID = z.uuid();
function record(value: unknown): Record<string, unknown> | undefined {
return value !== null && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
}
function revisions(config: PolicyConfig): Record<string, string> | undefined | null {
const value = config.accountAutoPausePolicyRevisions;
if (value === undefined) return undefined;
const map = record(value);
return map && Object.values(map).every(v => typeof v === "string" && UUID.safeParse(v).success) ? map as Record<string, string> : null;
}
function revisionFor(map: Record<string, string> | undefined | null, name: string): string | undefined {
return map && Object.hasOwn(map, name) ? map[name] : undefined;
}
function provider(config: PolicyConfig, name: string): Record<string, unknown> | undefined {
const providers = record(config.providers);
return providers && Object.hasOwn(providers, name) ? record(providers[name]) : undefined;
}
function route(row: Record<string, unknown> | undefined): string {
return JSON.stringify([row?.baseUrl, row?.adapter, row?.authMode]);
}
/**
* The policy a provider row actually runs. An explicit opt-in counts every permanent account
* refusal against its threshold. A row with no policy at all pauses only on a refusal the upstream
* itself marks permanent and account-wide, and only where one exists: a Cloud Code Assist OAuth
* provider on a first-party Google destination pauses the sending account on the first Terms of
* Service ban (#8752). A custom `baseUrl` could relay any refusal, so it needs the explicit opt-in.
* `enabled: false` opts out.
*/
export function effectiveAccountAutoPause(row: unknown): EffectiveAccountAutoPause | undefined {
const p = record(row);
if (!p) return;
if (p.accountAutoPause === undefined) {
return p.adapter === "google" && p.googleMode === "cloud-code-assist" && p.authMode === "oauth"
&& typeof p.baseUrl === "string" && isCanonicalAntigravityUrl(p.baseUrl) ? { threshold: 1, conclusiveOnly: true } : undefined;
}
const policy = record(p.accountAutoPause);
if (policy?.enabled !== true) return;
const threshold = policy.consecutiveFailures ?? 2;
return typeof threshold === "number" && Number.isInteger(threshold) && threshold >= 1 && threshold <= 100
? { threshold, conclusiveOnly: false } : undefined;
}
export function accountAutoPauseFingerprint(row: unknown): string {
const p = record(row), effective = effectiveAccountAutoPause(p);
return JSON.stringify([!!p, effective?.threshold ?? null, effective?.conclusiveOnly ?? null, p?.disabled === true, route(p)]);
}
export function snapshotAutoPauseFingerprints(config: PolicyConfig): Map<string, string> {
return new Map(Object.entries(record(config.providers) ?? {}).map(([name, row]) => [name, accountAutoPauseFingerprint(row)]));
}
/** Caller revisions never authorize a write. The literal pre-write file owns the epoch. */
export function normalizeAccountAutoPauseRevisions(before: PolicyConfig | undefined, persisted: OcxConfig): void {
const old = revisions(before ?? {});
const names = new Set(Object.keys(old ?? {}));
for (const config of [before, persisted]) {
for (const [name, row] of Object.entries(record(config?.providers) ?? {})) {
// A Cloud Code Assist row runs the default policy with no key, so it is tracked as well.
if (record(row)?.accountAutoPause !== undefined || effectiveAccountAutoPause(row)) names.add(name);
}
}
// Records follow the providers that exist after disk-only preservation; a deleted provider's
// record is reclaimed and a recreated one is minted a fresh UUID.
const entries = [...names].filter(name => hasProvider(persisted, name)).map(name => [name, revisionFor(old, name)
&& accountAutoPauseFingerprint(provider(before ?? {}, name)) === accountAutoPauseFingerprint(provider(persisted, name))
? revisionFor(old, name)! : randomUUID()]);
if (entries.length) persisted.accountAutoPausePolicyRevisions = Object.fromEntries(entries);
else delete persisted.accountAutoPausePolicyRevisions;
}
/** Adopt disk epochs even when an external ABA left the effective policy unchanged. */
export function observeAccountAutoPauseRevisions(config: PolicyConfig, disk: PolicyConfig = config, previous?: Map<string, string>): void {
const path = getConfigPath();
let entries = observed.get(path);
if (!entries) { entries = new Map(); observed.set(path, entries); }
const map = revisions(disk);
const names = new Set([...entries.keys(), ...Object.keys(record(config.providers) ?? {}), ...Object.keys(map ?? {})]);
for (const name of names) {
if (!hasProvider(config, name) && !hasProvider(disk, name)) { entries.delete(name); continue; }
const fingerprint = accountAutoPauseFingerprint(provider(config, name));
const old = entries.get(name);
const prior = previous?.get(name) ?? old?.fingerprint ?? fingerprint;
entries.set(name, { fingerprint, diskRevision: revisionFor(map, name) ?? "legacy", unknown: map === null,
diskFingerprint: accountAutoPauseFingerprint(provider(disk, name)),
localGen: !old || prior !== fingerprint ? allocateGeneration() : old.localGen });
}
}
/**
* A loaded snapshot adopts the disk epoch and compares its policy with the previously observed
* disk policy. Many callers read detached snapshots; comparing one with the live fingerprint would
* advance localGen on every live/snapshot difference. A disk-to-disk change still advances it.
*/
function adoptDiskAutoPauseRevisions(config: PolicyConfig): void {
const path = getConfigPath();
let entries = observed.get(path);
if (!entries) { entries = new Map(); observed.set(path, entries); }
const map = revisions(config);
for (const name of new Set([...entries.keys(), ...Object.keys(record(config.providers) ?? {}), ...Object.keys(map ?? {})])) {
if (!hasProvider(config, name)) { entries.delete(name); continue; }
const old = entries.get(name);
const diskRevision = revisionFor(map, name) ?? "legacy";
const diskFingerprint = accountAutoPauseFingerprint(provider(config, name));
entries.set(name, old
? { ...old, diskRevision, unknown: map === null, diskFingerprint, localGen: old.diskFingerprint !== diskFingerprint ? allocateGeneration() : old.localGen }
: { fingerprint: diskFingerprint, diskFingerprint, diskRevision, unknown: map === null, localGen: allocateGeneration() });
}
}
/** Test inspection only: observed records for the current config path. */
export function accountAutoPauseObservedSizeForTests(): number {
return observed.get(getConfigPath())?.size ?? 0;
}
/** Initial load is an observation, never a persistence operation. */
export function observeLoadedAutoPauseConfig(config: OcxConfig): OcxConfig {
adoptDiskAutoPauseRevisions(config);
return config;
}
export function captureAccountAutoPauseFence(config: OcxConfig, name: string): AccountAutoPauseFence | undefined {
// Only a config path no load or save has observed may be seeded from the caller's object. Once a
// path is observed, a missing name means an authoritative observation removed it, and a stale
// live snapshot must not re-enroll it; adoption by load, reload or save is required.
if (!observed.has(getConfigPath())) observeAccountAutoPauseRevisions(config);
const state = observed.get(getConfigPath())?.get(name);
const p = provider(config, name), effective = effectiveAccountAutoPause(p);
if (!state || state.unknown || !p || p.disabled === true || !effective) return;
return { configPath: getConfigPath(), diskRevision: state.diskRevision, localGen: state.localGen, ...effective, route: route(p) };
}
export function accountAutoPauseFenceIsLocal(name: string, fence: AccountAutoPauseFence): boolean {
const state = observed.get(fence.configPath)?.get(name);
return getConfigPath() === fence.configPath && !!state && !state.unknown
&& state.diskRevision === fence.diskRevision && state.localGen === fence.localGen;
}
/** Must run inside the config mutation lock at the final persistence boundary. */
export function accountAutoPauseFenceMatchesDisk(name: string, fence: AccountAutoPauseFence, fresh?: PolicyConfig): boolean {
if (!accountAutoPauseFenceIsLocal(name, fence)) return false;
try {
const disk = fresh ?? JSON.parse(readFileSync(fence.configPath, "utf8").replace(/^\uFEFF/, "")) as PolicyConfig;
const map = revisions(disk), p = provider(disk, name), effective = effectiveAccountAutoPause(p);
return map !== null && (revisionFor(map, name) ?? "legacy") === fence.diskRevision && !!p && p.disabled !== true
&& effective?.threshold === fence.threshold && effective.conclusiveOnly === fence.conclusiveOnly && route(p) === fence.route;
} catch { return false; }
}