@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
161 lines (146 loc) • 6.63 kB
text/typescript
/**
* Opt-in idle refresh so a reset is noticed while nobody is looking.
*
* This is load-bearing, not a convenience. fetchProviderQuotaReports has exactly one caller
* — the GET /api/provider-quotas route — so with no dashboard open and no CLI invocation it
* never runs, no second snapshot exists, and an overnight reset passes unobserved. That
* overnight case is the whole reason the subsystem exists.
*
* Shape follows src/storage/policy-scheduler.ts: a module-singleton unref'd interval whose
* config gate lives in the callee, so toggling `enabled` takes effect on the next tick
* without a restart (the rationale spelled out at src/oauth/token-guardian.ts:276).
*/
const DEFAULT_INTERVAL_MS = 15 * 60_000;
/**
* Above the 5-minute provider cache TTL and the 10-minute per-account TTL, so one tick costs
* at most one upstream probe per window rather than hammering a quota endpoint that
* rate-limits (src/providers/quota.ts:1425 records an observed 429 under repeated probing).
*/
export const MIN_INTERVAL_MS = 10 * 60_000;
let timer: ReturnType<typeof setInterval> | null = null;
let detachShutdownHook: (() => void) | null = null;
/** The bounded cadence the live timer was created with, so a tick can notice config drift. */
let liveIntervalMs: number | null = null;
/**
* Bumped by every start and stop. A tick captures it on entry and re-checks before publishing,
* so a probe still in flight when the poller stops cannot publish into the next generation.
*/
let generation = 0;
/** setInterval does not skip a firing while the previous callback is still awaiting. */
let inFlight = false;
/** Number of ticks that have run. Test-only observability; carries no quota data. */
let tickCount = 0;
function boundedInterval(value: number): number {
return Math.max(MIN_INTERVAL_MS, Math.floor(value));
}
/** Re-arm the timer when the operator changed the cadence since it was created. */
function restartIfCadenceChanged(configured: number): void {
if (timer === null || boundedInterval(configured) === liveIntervalMs) return;
stopQuotaResetPoller();
startQuotaResetPoller(configured);
}
async function tick(): Promise<void> {
// An interval firing while the previous probe is still awaiting would double the upstream
// load precisely when it is already slow.
if (inFlight) return;
inFlight = true;
const entryGeneration = generation;
try {
const { isQuotaResetNotificationEnabled, resolveQuotaResetPollMs } = await import(
"./reset-notify-config"
);
// Re-sync the sink on every tick, before the enable check bails out. This is what makes
// enabling or disabling notifications take effect without a restart: an install that starts
// with the section absent has no sink, and the seams therefore skip all work, so something
// has to notice the operator turned it on. Cheap — the resolver is mtime-cached.
const { syncQuotaResetActivation } = await import("./reset-activation");
await syncQuotaResetActivation();
if (!isQuotaResetNotificationEnabled()) return;
const configured = resolveQuotaResetPollMs();
if (configured === 0) return;
// A stop or restart landed while the config resolved: this tick no longer owns the timer,
// so it must neither count as a probe nor adopt a cadence for a generation that is gone.
if (entryGeneration !== generation) return;
// Adopt a changed cadence without a restart, which is why the config gate lives in the
// callee at all. Only while this tick still owns the timer.
restartIfCadenceChanged(configured);
tickCount += 1;
const [{ loadConfig }, { fetchProviderQuotaReports }] = await Promise.all([
import("../config"),
import("../providers/quota"),
]);
// A stop or restart landed while this probe was in flight: the result belongs to a
// generation that no longer owns the timer, so it must not publish.
if (entryGeneration !== generation) return;
// Forced: an unforced call would be served from the 5-minute cache and produce no new
// observation at all.
await fetchProviderQuotaReports(loadConfig(), true);
} catch {
// A failed probe is not an error worth surfacing: the next tick tries again.
} finally {
inFlight = false;
}
}
/** Idempotent. A second call while running is a no-op, matching startStorageCleanupScheduler. */
export function startQuotaResetPoller(intervalMs = DEFAULT_INTERVAL_MS): void {
if (timer) return;
const bounded = boundedInterval(intervalMs);
generation += 1;
liveIntervalMs = bounded;
timer = setInterval(() => void tick(), bounded);
// Never keep the process alive for a quota probe.
timer.unref?.();
void import("../lib/optional-shutdown-hooks")
.then(hooks => {
detachShutdownHook = hooks.registerOptionalShutdownHook(
"quota-reset-poller",
stopQuotaResetPoller,
);
})
.catch(() => {
// Without the hook the unref'd timer still cannot delay exit.
});
}
export function stopQuotaResetPoller(): void {
if (timer) {
clearInterval(timer);
timer = null;
}
liveIntervalMs = null;
generation += 1;
detachShutdownHook?.();
detachShutdownHook = null;
}
export function isQuotaResetPollerRunning(): boolean {
return timer !== null;
}
/**
* Adopt the operator's configured cadence at startup.
*
* The caller starts the poller synchronously with the default interval, because resolving the
* config here would mean a static edge to ../config from a module the quota boundary guard
* requires to have none. Resolving it through import() keeps that edge dynamic, at the cost of
* the timer running at the default for the few microtasks before this settles.
*/
export async function syncQuotaResetPollerCadence(): Promise<void> {
const { resolveQuotaResetPollMs } = await import("./reset-notify-config");
const configured = resolveQuotaResetPollMs();
// 0 is passive-only: tick() already returns before probing, and the timer stays unref'd.
if (configured === 0) return;
restartIfCadenceChanged(configured);
}
/** Test-only: run one tick synchronously rather than waiting out the interval. */
export async function runQuotaResetPollerTickForTests(): Promise<void> {
await tick();
}
export function quotaResetPollerTickCountForTests(): number {
return tickCount;
}
/** Test-only: the bounded cadence the live timer is running at, or null when stopped. */
export function quotaResetPollerIntervalForTests(): number | null {
return liveIntervalMs;
}
export function resetQuotaResetPollerForTests(): void {
stopQuotaResetPoller();
tickCount = 0;
}