@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
159 lines (146 loc) • 7.28 kB
text/typescript
/**
* Part B of the checked Windows service stop (#7771, 030 "Part B"), run by the caller
* after its graceful child stop: the port is free and stays free for one relaunch period,
* no wrapper of this home is running, and a remaining listener is classified.
*
* 1. Sample the port until it has been free for the 6 s hold, measured between sample
* starts, within the window from windowsPartBWindowMs (6-12 s, starting now). A loop that
* relaunches the proxy late breaks the streak.
* 2. Then, under one 5 s cap, run the final enumeration and, if the port is still held,
* identify its listener. The enumeration must show no wrapper-image process carrying
* this home's path token; an unreadable table is non-success, and a wrapper started
* after bind makes the stop survived even with the port free.
* 3. A remaining listener is ours (survived), foreign (portHeldByForeign) or left by an
* owner that has exited, which is not foreign: the caller's reclaim clears that one.
*
* Every effect is injected; nothing calls this yet.
*/
import type { WindowsStopProcessEntry } from "./windows-process-evidence";
import { windowsHomeWrapperPids } from "./windows-stop-binding";
import { runCapped, windowsStopClock, type WindowsStopClock } from "./windows-checked-stop";
import { commandLineHasPathToken } from "./windows-command-line-token";
import { WINDOWS_STOP_CAPS, windowsPartBWindowMs } from "./windows-stop-budget";
type MaybePromise<T> = T | Promise<T>;
export type WindowsPortSample =
| { state: "free" }
| { state: "listening"; ownerPid: number | null }
| { state: "unknown" };
/** ours = this installation's identity answers; exited = the owning process is gone. */
export type WindowsListenerIdentity = "ours" | "foreign" | "exited" | "unknown";
export interface WindowsStopConfirmDeps {
clock?: WindowsStopClock;
port: number;
/** Time left in the caller's deadline when Part B starts. */
remainingMs: number;
reserveMs?: number;
canonicalPaths: readonly string[];
selfPid?: number;
samplePort(port: number, timeoutMs: number): MaybePromise<WindowsPortSample>;
identifyListener(port: number, ownerPid: number | null, timeoutMs: number): MaybePromise<WindowsListenerIdentity>;
enumerate(timeoutMs: number): MaybePromise<readonly WindowsStopProcessEntry[] | null>;
}
export type WindowsStopConfirmOutcome = "freed" | "survived" | "port-held-by-foreign" | "unconfirmed" | "unknown";
export interface WindowsStopConfirmResult {
outcome: WindowsStopConfirmOutcome;
portHeldByForeign: boolean;
reason: "evidence-unreadable" | null;
detail: string;
port: number;
windowMs: number;
listener: { ownerPid: number | null; identity: WindowsListenerIdentity } | null;
/** Wrapper-image processes of this home found by the final enumeration. */
lateWrappers: number[];
}
const C = WINDOWS_STOP_CAPS;
const SAMPLE_INTERVAL_MS = 250;
export async function confirmWindowsStopFreed(deps: WindowsStopConfirmDeps): Promise<WindowsStopConfirmResult> {
const clock = deps.clock ?? windowsStopClock;
const windowMs = windowsPartBWindowMs(deps.remainingMs, deps.reserveMs ?? C.reserve);
const windowEnd = clock.now() + windowMs;
const result: WindowsStopConfirmResult = {
outcome: "unknown", portHeldByForeign: false, reason: null, detail: "",
port: deps.port, windowMs, listener: null, lateWrappers: [],
};
const finish = (outcome: WindowsStopConfirmOutcome, detail: string): WindowsStopConfirmResult => {
result.outcome = outcome;
result.portHeldByForeign = outcome === "port-held-by-foreign";
result.reason = outcome === "unknown" ? "evidence-unreadable" : null;
result.detail = detail;
return result;
};
let freeSince: number | null = null;
let held = false;
let last: WindowsPortSample = { state: "unknown" };
for (;;) {
const startedAt = clock.now();
const sample = await runCapped(clock, C.partBClosingSample, timeoutMs => deps.samplePort(deps.port, timeoutMs));
last = sample.ok ? sample.value : { state: "unknown" };
if (last.state === "free") {
freeSince ??= startedAt;
if (startedAt - freeSince >= C.partBHoldFloor) {
held = true;
break;
}
} else {
freeSince = null;
}
const left = windowEnd - clock.now();
if (left <= 0) break;
await clock.sleep(Math.min(SAMPLE_INTERVAL_MS, left));
}
const listening = last.state === "listening" ? last : null;
const [snapshot, identity] = await Promise.all([
runCapped(clock, C.partBFinalEnumeration, deps.enumerate),
listening
? runCapped(clock, C.partBFinalEnumeration,
timeoutMs => deps.identifyListener(deps.port, listening.ownerPid, timeoutMs))
: Promise.resolve(null),
]);
if (listening) {
result.listener = {
ownerPid: listening.ownerPid,
identity: identity && identity.ok ? identity.value : "unknown",
};
}
const processes = snapshot.ok ? snapshot.value : null;
if (processes) {
result.lateWrappers = windowsHomeWrapperPids(processes, deps.canonicalPaths, deps.selfPid ?? process.pid);
}
if (result.lateWrappers.length > 0) return finish("survived", "a wrapper of this home is running after the stop");
if (result.listener?.identity === "ours") return finish("survived", "this installation answers on the port again");
if (processes === null) return finish("unknown", "the final process list could not be read");
const unnamed = processes.some(entry => entry.name === null && entry.foreignOwner !== true && entry.pid !== (deps.selfPid ?? process.pid)
&& deps.canonicalPaths.some(path => commandLineHasPathToken(entry.commandLine, path)));
if (unnamed) return finish("unknown", "a process carrying this home's paths has an unreadable image name");
if (held) return finish("freed", "the port stayed free for the hold and no wrapper of this home is running");
if (result.listener?.identity === "foreign") return finish("port-held-by-foreign", "another program holds the port");
if (result.listener?.identity === "exited") {
return finish("unconfirmed", "the port is held by a listener whose owner has exited");
}
if (last.state === "free") return finish("unconfirmed", "the port was not free for the whole hold within the window");
return finish("unknown", "the port state could not be read");
}
/**
* Which port Part B watches: the runtime-port record when present, else the port baked
* into the wrapper script, else the configured port.
*/
export function resolveWindowsStopPort(sources: {
runtimePort: () => number | null;
wrapperPort: () => number | null;
configuredPort: () => number;
}): { port: number; source: "runtime" | "wrapper" | "config" } {
const valid = (value: number | null): value is number =>
value !== null && Number.isSafeInteger(value) && value > 0 && value <= 65_535;
const read = (get: () => number | null): number | null => {
try {
return get();
} catch {
return null;
}
};
const runtime = read(sources.runtimePort);
if (valid(runtime)) return { port: runtime, source: "runtime" };
const wrapper = read(sources.wrapperPort);
if (valid(wrapper)) return { port: wrapper, source: "wrapper" };
return { port: sources.configuredPort(), source: "config" };
}