UNPKG

@bitkyc08/opencodex

Version:

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

89 lines (83 loc) • 3.83 kB
export interface KillableSubprocess { exited: Promise<number>; kill(): unknown; unref?(): unknown; } export interface BoundedSubprocessExit { exitCode: number | null; timedOut: boolean; } export type SubprocessDeadlineScheduler = ( callback: () => void, milliseconds: number, ) => () => void; const scheduleDeadline: SubprocessDeadlineScheduler = (callback, milliseconds) => { const timer = setTimeout(callback, milliseconds); return () => clearTimeout(timer); }; /** * Compatibility allowance used by the ACL runner's outer watchdog. * * `kill()` only REQUESTS termination. It returns before the kernel has torn the process down, and * every handle that process holds stays held until it does. On Windows that is not a detail: file * locking is mandatory, so a directory an abandoned `icacls.exe` still has open cannot be removed * by anyone, and the removal fails with EPERM rather than waiting. */ export const SUBPROCESS_KILL_GRACE_MS = 2_000; /** * Wait for a child until the deadline. At the deadline, kill it AND wait for it to actually die. * * This used to kill, `unref`, and resolve in the same tick, which made every caller's "I waited * for my child" guarantee false precisely when it mattered. The ACL runner now waits here until * actual exit; if its separate caller-facing belt fires first, that layer registers the target so * removal can wait for the reap without making ordinary startup or shutdown unbounded. * * That cost three failed fixes. #4789 blamed the removal retry budget and asked for more than * 2.5s; #4796 gave it a 15s exponential schedule; a later change awaited the hardening flight from * the test hook. Windows shard 1/6 failed identically through all three, because none of them * addressed a live process holding the handle -- run 35108652486 burned the full 15s budget and * still threw `EPERM ... rm ocx-management-auth-fDchUb`, with two * `ACL hardening timed out (ETIMEDOUT) - transient icacls stall` lines logged beside it. * * The old grace still abandoned a live child after two seconds. That recreated the same false * ownership contract on a slower clock: the ACL flight settled, cleanup removed the directory, * and Windows returned EPERM because the child still held it. A handle-bearing caller therefore * has no second deadline after kill. The child's actual exit is the only release signal. * * Pass `0` to opt out for a child that holds no path anyone will remove. The numeric form is kept * for compatibility with the existing callers; any positive value means that reaping is required. * The injected scheduler is a test seam so deadline and exit ordering can be proved without sleep. */ export function waitForSubprocessExit( proc: KillableSubprocess, timeoutMs: number, reapAfterKill: number = SUBPROCESS_KILL_GRACE_MS, schedule: SubprocessDeadlineScheduler = scheduleDeadline, ): Promise<BoundedSubprocessExit> { return new Promise(resolve => { let settled = false; let deadlineFired = false; let cancelDeadline: (() => void) | undefined; const finish = (result: BoundedSubprocessExit): void => { if (settled) return; settled = true; cancelDeadline?.(); resolve(result); }; const reaped = proc.exited.then( exitCode => finish(deadlineFired ? { exitCode: null, timedOut: true } : { exitCode, timedOut: false }), () => finish({ exitCode: null, timedOut: deadlineFired }), ); cancelDeadline = schedule(() => { deadlineFired = true; try { proc.kill(); } catch { /* already exited */ } if (reapAfterKill <= 0) { try { proc.unref?.(); } catch { /* abandonment is still authoritative */ } finish({ exitCode: null, timedOut: true }); return; } }, Math.max(1, timeoutMs)); }); }