@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
199 lines (176 loc) • 5.87 kB
text/typescript
export const STATE_SWEEP_INTERVAL_MS = 60_000;
export interface GenerationContext {
generation: number;
providerNames: ReadonlySet<string>;
comboIds: ReadonlySet<string>;
comboTargets: ReadonlySet<string>;
codexAccountIds: ReadonlySet<string>;
oauthAccountKeys: ReadonlySet<string>;
configRoots: ReadonlySet<string>;
}
export interface StateStoreRegistration {
name: string;
sweepExpired?: (now: number) => number;
sweepLiveness?: () => number;
reconcileGeneration?: (context: GenerationContext) => number;
}
export interface StateSweepAfterTickRegistration {
name: string;
afterTick(): void;
}
export interface StateSweepResult {
storesVisited: number;
rowsRemoved: number;
}
export interface StateStoreSweeperOptions {
/** Override the 60 s interval (tests only; production uses the default). */
intervalMs?: number;
/** Injectable clock for tests. */
now?: () => number;
}
const registrations = new Map<string, StateStoreRegistration>();
interface AfterTickRegistrationNode {
registration: StateSweepAfterTickRegistration;
previous: AfterTickRegistrationNode | null;
active: boolean;
}
const afterTickRegistrations = new Map<string, AfterTickRegistrationNode>();
let configGeneration = 0;
let attemptSequence = 0;
let generationContextBuilder: (() => GenerationContext) | null = null;
let reconciliationRetryPending = false;
let interval: ReturnType<typeof setInterval> | null = null;
function logCallbackFailure(name: string): void {
console.warn(`[state-store-sweeper] ${name} failed`);
}
export function registerStateStore(registration: StateStoreRegistration): () => void {
registrations.set(registration.name, registration);
return () => {
if (registrations.get(registration.name) === registration) {
registrations.delete(registration.name);
}
};
}
export function registerStateSweepAfterTick(registration: StateSweepAfterTickRegistration): () => void {
const node: AfterTickRegistrationNode = {
registration,
previous: afterTickRegistrations.get(registration.name) ?? null,
active: true,
};
afterTickRegistrations.set(registration.name, node);
return () => {
node.active = false;
if (afterTickRegistrations.get(registration.name) !== node) return;
let previous = node.previous;
while (previous && !previous.active) previous = previous.previous;
if (previous) afterTickRegistrations.set(registration.name, previous);
else afterTickRegistrations.delete(registration.name);
};
}
function runCallbacks(
callback: (registration: StateStoreRegistration) => (() => number) | undefined,
): StateSweepResult {
let storesVisited = 0;
let rowsRemoved = 0;
for (const registration of registrations.values()) {
const invoke = callback(registration);
if (!invoke) continue;
storesVisited += 1;
try {
rowsRemoved += invoke();
} catch {
logCallbackFailure(registration.name);
}
}
return { storesVisited, rowsRemoved };
}
export function sweepExpired(now = Date.now()): StateSweepResult {
return runCallbacks(registration => registration.sweepExpired
? () => registration.sweepExpired!(now)
: undefined);
}
export function sweepExpiredOnWrite(now = Date.now()): StateSweepResult {
const result = sweepExpired(now);
if (reconciliationRetryPending && generationContextBuilder) {
try {
reconcileStateGeneration(generationContextBuilder());
} catch {
// The builder reads authoritative live owners. Keep the single retry pending
// until a later successful owner write can obtain a complete context.
}
}
return result;
}
export function sweepLiveness(): StateSweepResult {
return runCallbacks(registration => registration.sweepLiveness);
}
function runAfterTickCallbacks(): void {
for (const { registration } of afterTickRegistrations.values()) {
try {
registration.afterTick();
} catch {
logCallbackFailure(registration.name);
}
}
}
export function captureConfigGeneration(): number {
return configGeneration;
}
export function setGenerationContextBuilder(build: () => GenerationContext): void {
generationContextBuilder = build;
}
export function reconcileStateGeneration(context: GenerationContext): StateSweepResult {
const candidateGeneration = ++attemptSequence;
const candidateContext: GenerationContext = {
...context,
generation: candidateGeneration,
};
let storesVisited = 0;
let rowsRemoved = 0;
let failed = false;
for (const registration of registrations.values()) {
if (!registration.reconcileGeneration) continue;
storesVisited += 1;
try {
rowsRemoved += registration.reconcileGeneration(candidateContext);
} catch {
failed = true;
logCallbackFailure(registration.name);
}
}
if (failed) {
reconciliationRetryPending = true;
} else {
configGeneration = candidateGeneration;
reconciliationRetryPending = false;
}
return { storesVisited, rowsRemoved };
}
export function startStateStoreSweeper(
options: StateStoreSweeperOptions = {},
): { stop(): void } {
stopStateStoreSweeper();
const now = options.now ?? Date.now;
interval = setInterval(() => {
sweepExpired(now());
sweepLiveness();
runAfterTickCallbacks();
}, options.intervalMs ?? STATE_SWEEP_INTERVAL_MS);
interval.unref?.();
return { stop: stopStateStoreSweeper };
}
export function stopStateStoreSweeper(): void {
if (!interval) return;
clearInterval(interval);
interval = null;
}
/** Test-only reset for module-global registrations, generation, and lifecycle state. */
export function resetStateStoreSweeperForTests(): void {
stopStateStoreSweeper();
registrations.clear();
afterTickRegistrations.clear();
configGeneration = 0;
attemptSequence = 0;
generationContextBuilder = null;
reconciliationRetryPending = false;
}