@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
156 lines (145 loc) • 8.09 kB
text/typescript
/**
* Replacing the runtime that still serves an old version after a Desktop MSI install (#8246).
*
* Windows Installer replaces `ocx.exe` on disk but leaves running processes alone, so the old
* runtime keeps answering /healthz with its old version. This module only ever acts on a runtime
* this home attests (its runtime record and per-process secret) whose image is the installed
* `ocx.exe` being updated. It asks that runtime for its own bound in-place restart, the same
* owner-aware path `ocx restart` uses: a Desktop-supervised child hands its replacement to the
* Desktop app (which starts the sibling `ocx.exe`), a service child exits for its manager, and a
* detached runtime relaunches its own image. All three now run the installed bytes.
*
* A connected-client runtime under the Desktop app refuses that restart (409
* `restart_supervised_desktop`): it keeps itself until its owner replaces it. When the Desktop
* supervision probe proves this installation's app is the parent of exactly that pid, the runtime
* is drained with the installed `ocx stop --json`, the same stop the app's own updater drain runs,
* and the app's supervisor starts its sibling `ocx.exe` again after its backoff.
*
* Success is a different process answering with the target version; anything else is reported,
* never assumed. A runtime from another installation, an unattested one, or a newer one is not
* touched.
*/
import { win32 } from "node:path";
import type { LiveProxy } from "../server/proxy-liveness";
import type { ProxyRestartRequestOutcome } from "../cli/tray-proxy";
import { computeVersionSkew } from "../cli/version-skew";
export interface RuntimeReplaceDeps {
findLive(): Promise<LiveProxy | null>;
/** Drive-qualified image path of the process, or null when it cannot be read. */
runtimeImage(pid: number): string | null;
requestRestart(live: LiveProxy & { pid: number }, targetVersion: string): Promise<ProxyRestartRequestOutcome>;
/** The Desktop app image proven to supervise exactly this runtime pid, or null. */
desktopSupervisor(pid: number): string | null;
/** Drain the runtime with the installed CLI's `ocx stop --json`; ok only for a confirmed stop. */
drainRuntime(): Promise<{ ok: boolean; detail?: string }>;
/** Restart this installation's background service with the installed `ocx service restart`. */
restartService(): Promise<{ ok: boolean; detail?: string }>;
now(): number;
wait(ms: number): Promise<void>;
}
export type StaleRuntimeReason =
| "unknown-version"
| "runtime-newer"
| "incomparable"
| "unattested"
| "foreign-image"
| "restart-refused"
| "drain-failed"
| "service-restart-failed"
| "replacement-timeout";
export type RuntimeOutcome =
| { kind: "serving-target"; live: LiveProxy; replaced: boolean }
| { kind: "not-running" }
| { kind: "stale"; live: LiveProxy | null; reason: StaleRuntimeReason; detail?: string };
export const RUNTIME_OBSERVE_INTERVAL_MS = 250;
/** Windows paths compare case-insensitively and with either separator. */
export function sameWindowsPath(left: string, right: string): boolean {
const normalize = (path: string) => path.replaceAll("/", "\\").replace(/\\+$/, "").toLowerCase();
return normalize(left) === normalize(right);
}
/** Name the updater gives the running `ocx.exe` it moves aside before Windows Installer runs. */
export const MOVED_IMAGE_PATTERN = /^ocx\.exe\.\d+-\d+\.update-old$/i;
export function movedImageName(pid: number, at: number): string {
return `ocx.exe.${pid}-${at}.update-old`;
}
/**
* The installed executable, or a previous image of it that this updater moved aside in the same
* directory: Windows may report a running process under the name its image file has now.
*/
export function isInstalledImage(image: string, installedExe: string): boolean {
if (sameWindowsPath(image, installedExe)) return true;
const normalized = image.replaceAll("/", "\\");
return sameWindowsPath(win32.dirname(normalized), win32.dirname(installedExe)) && MOVED_IMAGE_PATTERN.test(win32.basename(normalized));
}
/**
* Make the serving runtime the installed version.
*
* `wasRunning` says whether a runtime answered before the install; without one this never starts
* a runtime just to prove the update, and reports `not-running` instead.
*/
export async function settleRuntime(
input: { installedExe: string; targetVersion: string; deadlineAt: number; wasRunning: boolean; expectedPort?: number },
deps: RuntimeReplaceDeps,
): Promise<RuntimeOutcome> {
const found = await deps.findLive();
// Only this home's attested runtime record identifies the runtime this installation serves; a
// proxy found on the configured port without it may belong to another home.
const live = found && found.source === "runtime" && found.pid !== null ? found : null;
if (!live) {
if (input.wasRunning && input.expectedPort !== undefined) return observe(input, deps, null, input.expectedPort);
if (!found || found.version === input.targetVersion) return { kind: "not-running" };
return { kind: "stale", live: found, reason: "unattested" };
}
if (live.version === input.targetVersion) return { kind: "serving-target", live, replaced: false };
if (!live.version) return { kind: "stale", live, reason: "unknown-version" };
const relation = computeVersionSkew(input.targetVersion, live.version).relation;
if (relation === "proxy-newer") return { kind: "stale", live, reason: "runtime-newer" };
if (relation !== "cli-newer") return { kind: "stale", live, reason: "incomparable" };
const pid = live.pid!;
let image: string | null;
try { image = deps.runtimeImage(pid); } catch { image = null; }
if (!image || !isInstalledImage(image, input.installedExe)) {
return { kind: "stale", live, reason: "foreign-image", ...(image ? { detail: image } : {}) };
}
const request = await deps.requestRestart({ ...live, pid }, input.targetVersion);
if (!request.accepted && !request.uncertain) {
const detail = request.error instanceof Error ? request.error.message : undefined;
if (detail === "restart_supervised_service") {
// The runtime's own image is this installation's, so its service runs the installed bytes;
// `ocx service restart` is the owner path the refusal names.
const restarted = await deps.restartService();
if (!restarted.ok) return { kind: "stale", live, reason: "service-restart-failed", ...(restarted.detail ? { detail: restarted.detail } : {}) };
return observe(input, deps, pid, live.port);
}
if (detail === "restart_supervised_desktop") {
let app: string | null;
try { app = deps.desktopSupervisor(pid); } catch { app = null; }
if (app && sameWindowsPath(win32.dirname(app), win32.dirname(input.installedExe))) {
const drained = await deps.drainRuntime();
if (!drained.ok) return { kind: "stale", live, reason: "drain-failed", ...(drained.detail ? { detail: drained.detail } : {}) };
return observe(input, deps, pid, live.port);
}
}
return { kind: "stale", live, reason: "restart-refused", ...(detail ? { detail } : {}) };
}
// An uncertain answer may still have been accepted: observe instead of asking twice.
return observe(input, deps, pid, live.port);
}
async function observe(
input: { targetVersion: string; deadlineAt: number },
deps: RuntimeReplaceDeps,
oldPid: number | null,
port: number,
): Promise<RuntimeOutcome> {
let last: LiveProxy | null = null;
while (deps.now() < input.deadlineAt) {
last = await deps.findLive();
// Bound to the replaced runtime: this home's attested record, on the same port, with a new pid.
if (last && last.source === "runtime" && last.port === port && last.version === input.targetVersion
&& last.pid !== null && last.pid !== oldPid) {
return { kind: "serving-target", live: last, replaced: true };
}
await deps.wait(Math.max(0, Math.min(RUNTIME_OBSERVE_INTERVAL_MS, input.deadlineAt - deps.now())));
}
return { kind: "stale", live: last, reason: "replacement-timeout" };
}