UNPKG

@bitkyc08/opencodex

Version:

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

131 lines (119 loc) • 4.96 kB
import { packageManifestPathIn, readPackageManifestVersionAt, sameObservation, type PackageTreeObservation, } from "./package-tree-integrity"; /** * The package a service launcher would start right now: its canonical root and the identity of * the manifest inside it. Null when the launcher, its target or the manifest cannot be resolved. */ export interface LauncherTarget { readonly root: string; readonly manifest: PackageTreeObservation; } export type ResolveLauncherTarget = () => LauncherTarget | null; export interface PackageTreeRetargetOptions { /** How often the launcher is re-resolved. Detection must not depend on inbound requests. */ pollIntervalMs?: number; /** How long one complete target identity must hold before the restart is requested. */ settleMs?: number; now?: () => number; /** Test seam; production uses an unref'd timer and returns its cancellation. */ schedule?: (callback: () => void, delayMs: number) => () => void; /** Test seam for the settled target's version; production reads its package manifest. */ readVersion?: (root: string) => string | undefined; } export interface PackageTreeRetargetWatch { /** * Version of the package the launcher now starts, once that target has held for the full * settle interval and still resolves to the same identity. A fenced `/healthz` reports it * when the running tree itself has gone, so `ocx restart` compares against what the * supervisor will actually start. */ settledVersion(): string | undefined; /** Stops polling and invalidates any pending restart request. */ dispose(): void; } const DEFAULT_POLL_INTERVAL_MS = 5_000; const DEFAULT_SETTLE_MS = 5_000; function sameTarget(left: LauncherTarget, right: LauncherTarget): boolean { return left.root === right.root && sameObservation(left.manifest, right.manifest); } /** * Watches a version-manager launcher whose target can move to a different package tree while the * running tree stays intact. * * The package-tree integrity fence only sees its own manifest. A manager that installs every * version into its own directory and then repoints a floating link (mise's `latest`) never * touches that manifest, so the fence neither restarts onto the new version nor recovers when * the old version is later pruned from under it. This watch compares what the launcher resolves * to with the running root instead. * * `onRetargeted` runs once, after one complete target identity (canonical root plus manifest * identity) has held for `settleMs`. Any change of either part, an unresolvable launcher, or a * return to the running root restarts the wait. A throwing handler is retried after another full * interval. After the supervisor restarts through the launcher, the new process's running root * is the target, so it never requests a second restart. */ export function createPackageTreeRetargetWatch( runningRoot: string, resolveTarget: ResolveLauncherTarget, onRetargeted: () => void, options: PackageTreeRetargetOptions = {}, ): PackageTreeRetargetWatch { const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS; const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS; const now = options.now ?? Date.now; const readVersion = options.readVersion ?? (root => readPackageManifestVersionAt(packageManifestPathIn(root))); const schedule = options.schedule ?? ((callback, delayMs) => { const timer = setTimeout(callback, delayMs); timer.unref?.(); return () => clearTimeout(timer); }); let stopped = false; let cancelPoll: (() => void) | null = null; let candidate: LauncherTarget | null = null; let candidateSince = 0; let settled: LauncherTarget | null = null; const poll = (): void => { cancelPoll = null; if (stopped) return; const target = resolveTarget(); if (target === null || target.root === runningRoot) { candidate = null; settled = null; } else if (candidate === null || !sameTarget(candidate, target)) { candidate = target; candidateSince = now(); settled = null; } else if (now() - candidateSince >= settleMs) { settled = target; try { onRetargeted(); stopped = true; return; } catch { // Restart admission refused (for example, the service home changed owner). Keep the // settled identity and ask again only after another full interval. candidateSince = now(); } } cancelPoll = schedule(poll, pollIntervalMs); }; cancelPoll = schedule(poll, pollIntervalMs); return { settledVersion: () => { if (settled === null) return undefined; const current = resolveTarget(); if (current === null || !sameTarget(settled, current)) return undefined; return readVersion(settled.root); }, dispose: () => { stopped = true; const cancel = cancelPoll; cancelPoll = null; cancel?.(); }, }; }