@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
309 lines (304 loc) • 20.8 kB
text/typescript
import { writeFileSync } from "node:fs";
import { randomUUID } from "node:crypto";
import { win32 } from "node:path";
import type { CodexCliApplyDeps, CodexCliApplyResult, CodexCliApplyCleanupError } from "./cli-update-apply";
import { createCodexCliUpdatePlan, createNpmConfigIsolation } from "./cli-update-plan";
import { inspectCodexCliInstall, observeCodexCliSelectedCommand } from "./cli-install-provenance";
import { holdWindowsCodexCliPlanToolchain, windowsCodexCliPlanEvidence, windowsCodexCliSelectionMatches } from "./cli-windows-plan-provenance";
import { openWindowsCliApplyAuthority, WindowsCliToolchainCleanupError, type WindowsApplyAcquisition } from "./cli-update-job-store-windows";
import { flushWindowsSecretAclReapsBeforeRemoval } from "../lib/windows-secret-acl";
import { verifyWindowsCodexCliLayout, matchesWindowsCodexCliLayout } from "./cli-update-windows-layout";
import { observeWindowsInstall, sameWindowsInstall, sameWindowsPreservedEntries, windowsCodexOwnedPath,
type WindowsInstallSnapshot } from "./cli-update-windows-observation";
import { scanCodexSessionProcesses } from "./app-server-processes";
import { startWindowsCliChild, cleanupUnstartedWindowsChild, type WindowsCliChild,
type WindowsCliChildInvocation, type WindowsCliChildResult } from "./windows-cli-child";
import { windowsNpmExecutionArgs } from "./windows-npm-execution";
type Authority = Awaited<ReturnType<typeof openWindowsCliApplyAuthority>>;
type Toolchain = NonNullable<Awaited<ReturnType<typeof holdWindowsCodexCliPlanToolchain>>>;
interface Owner { retention?: { release(): void }; authority: Authority; staging: string; toolchain: Toolchain | null; child?: WindowsCliChild;
recover?: () => Promise<boolean> }
// Strong owners survive an uncertain native wait and the HTTP/CLI caller returning.
// Never collect these as ordinary cleanup, infer terminal from a PID, or start a retry.
const retained = new Set<Owner>();
/** Explicit same-process reconciliation, using only the retained original native
* process/Job handles. Never retry installation or infer termination from a PID.
*/
export async function recoverWindowsCodexCliInstallations(): Promise<number> {
let recovered = 0;
for (const owner of retained) if (await owner.recover?.()) recovered++;
return recovered;
}
function npmArgs(args: readonly string[], isolation: ReturnType<typeof createNpmConfigIsolation>) {
return [...args, "--registry=https://registry.npmjs.org", `--userconfig=${isolation.npmrc}`,
`--globalconfig=${isolation.globalNpmrc}`, `--cache=${isolation.cache}`];
}
function expectedDirectories(files: readonly { relativePath: string }[], snapshot: WindowsInstallSnapshot): boolean {
const expected = new Set<string>();
for (const file of files) {
const parts = file.relativePath.split("/");
for (let i = 3; i < parts.length; i++) expected.add(parts.slice(0, i).join("/"));
}
const directories = snapshot.directories.filter(dir => windowsCodexOwnedPath(dir.split(":")[0]!));
return directories.length === expected.size && [...expected].every(path =>
directories.some(directory => directory.startsWith(path + ":")));
}
/** Explicit apply only. Shared prefix entries are bounded preservation obligations; ARM64 refuses.
* Outcomes describe the scoped installation's observed state, never filesystem-wide no-I/O.
* The existing admission layer owns confirmed/planId and durable result persistence.
*/
export async function applyWindowsCodexCliUpdate(planId: string, deps: CodexCliApplyDeps): Promise<CodexCliApplyResult> {
const cancelled = () => deps.signal?.aborted === true || deps.isCancelled?.() === true;
let owner: Owner | undefined, uncertain = false, cleanupPending = false, installerStarted = false;
let ownerRegistrationPending = false;
let installationWindowHeld = false;
let recoveryAllowed = false;
let installedVersion: string | null = null, targetVersion: string | null = null, exitCode: number | null = null;
let verificationPid: number | null = null, output: CodexCliApplyResult | undefined;
const finish = (outcome: CodexCliApplyResult["outcome"], reason: string): CodexCliApplyResult => output = {
outcome, reason, planId, installedVersion, targetVersion, installerExitCode: exitCode,
leaseRetained: uncertain || cleanupPending || ownerRegistrationPending, verificationPid, cleanupErrors: cleanupPending ? ["child_cleanup_failed"] : [],
};
const inspection = () => {
const input = { ...deps.inspectionDeps, platform: "win32" as const, observeInstallContent: true };
return { ...input, selectedCommand: observeCodexCliSelectedCommand(input) };
};
const inspect = () => (deps.inspect ?? inspectCodexCliInstall)(inspection());
const plan = () => createCodexCliUpdatePlan({ ...deps, platform: "win32", inspectionDeps: inspection() });
const settle = async (child: WindowsCliChild): Promise<WindowsCliChildResult> => {
if (!owner) throw new Error("ownership_required");
if (!child.process) {
const cleaned = await cleanupUnstartedWindowsChild(child);
uncertain = false; cleanupPending = !cleaned;
if (cleaned) owner.child = undefined;
return { terminal: true, cleanupComplete: cleaned, exitCode: null, stdout: "", failed: true, overflow: false, reason: child.setupFailure };
}
const result = await child.wait();
uncertain = !result.terminal;
cleanupPending = result.terminal && !result.cleanupComplete;
if (result.terminal && result.cleanupComplete) owner.child = undefined;
return result;
};
const startOwned = (invocation: WindowsCliChildInvocation): WindowsCliChild => {
if (!owner || owner.child) throw new Error("child_cleanup_pending");
uncertain = true; // A throwing start may already have created native resources.
const jobName = installerStarted ? `Global\\ocx-cli-${randomUUID()}` : undefined;
const proof = jobName ? deps.commitWindow?.childStarting?.(jobName) : undefined;
const child = owner.child = (deps.startWindowsChild ?? startWindowsCliChild)({ ...invocation,
recoveryJobName: jobName, recoveryProof: proof || undefined });
if (jobName && child.pid && child.creationTime) deps.commitWindow?.childStarted?.(child.pid,
{ jobName, creationTime: child.creationTime });
return child;
};
const run = async (invocation: WindowsCliChildInvocation): Promise<WindowsCliChildResult> => {
if (!owner) throw new Error("ownership_required");
await owner.authority.verify();
if (!installerStarted && cancelled()) throw new Error("cancelled");
return settle(startOwned(invocation));
};
try {
if (!/^[0-9a-f]{32}$/.test(planId)) return finish("refused", "invalid_plan_id");
if (process.platform !== "win32" || process.arch !== "x64") return finish("refused", "windows_inspection_deferred");
if (cancelled()) return finish("refused", "cancelled");
const first = await inspect(), evidence = windowsCodexCliPlanEvidence(first);
installedVersion = first.packageVersion;
if (!first.managed || !evidence || evidence.arch !== "x64") return finish("refused", "mutation_evidence_unverified");
if (cancelled()) return finish("refused", "cancelled");
const initialPlan = await plan(); targetVersion = initialPlan.targetVersion;
if (cancelled()) return finish("refused", "cancelled");
if (!initialPlan.applicable) return finish("refused", initialPlan.refusal ?? "plan_refused");
if (initialPlan.planId !== planId) return finish("refused", "plan_changed");
const artifacts = initialPlan.targetArtifacts;
if (!artifacts || artifacts.platform !== "win32" || artifacts.arch !== "x64") return finish("refused", "target_artifacts_unverified");
// Root the acquisition anchor before await/Owner registration. If registration
// throws, the Worker token still owns any acquired authority through this anchor.
const anchor: { acquisition?: WindowsApplyAcquisition; authority?: Authority; owner?: Owner } = {};
const retention = deps.retainExecution?.(anchor);
let authority: Authority;
try {
authority = anchor.authority = await openWindowsCliApplyAuthority(evidence.prefix, true,
acquisition => { anchor.acquisition = acquisition; });
} catch (error) {
// Authority's finally has already attempted cleanup, without retrying failed pins.
// A rejected acquisition can still own handles even though no Authority was returned.
if (anchor.acquisition && !anchor.acquisition.releaseIfClean(retention)) {
ownerRegistrationPending = true;
return finish("ambiguous", "installer_or_readback_error");
}
if (!anchor.acquisition) retention?.release(); // Native load/validation failed before any ctx existed.
return finish("refused", error instanceof Error && error.message === "job_store_busy"
? "installation_busy" : "installation_prefix_unsupported");
}
ownerRegistrationPending = true;
owner = anchor.owner = { retention, authority, staging: win32.join(authority.lock, "stage"), toolchain: null };
retained.add(owner);
ownerRegistrationPending = false;
let recovering = false, recoveryTerminal = false;
owner.recover = async () => {
if (!recoveryAllowed || recovering || !owner || (!recoveryTerminal
&& (!uncertain || !owner.child || !owner.child.process || !owner.child.observe().terminal))) return false;
recovering = true;
try {
if (!recoveryTerminal) {
const settled = await settle(owner.child!);
if (!settled.terminal || !settled.cleanupComplete) return false;
recoveryTerminal = true; // Survives transient authority/readback failure.
}
// Readback is required before reopening the shared installation, even
// though this recovery never upgrades the earlier ambiguous job result.
await owner.authority.verify();
await observeWindowsInstall(evidence.prefix); await inspect();
if (installationWindowHeld) { deps.commitWindow!.exit(); installationWindowHeld = false; }
await flushWindowsSecretAclReapsBeforeRemoval(owner.staging);
await owner.authority.removeStaging();
if (owner.toolchain && !await owner.toolchain.release()) return false;
await owner.authority.release();
if (!owner.authority.resourcesReleased) return false;
retained.delete(owner); owner.retention?.release(); return true;
} catch { return false; } finally { recovering = false; }
};
await authority.createStaging();
if (cancelled()) return finish("refused", "cancelled");
owner.toolchain = await holdWindowsCodexCliPlanToolchain(first);
if (cancelled()) return finish("refused", "cancelled");
if (!owner.toolchain) return finish("refused", "npm_unavailable");
const isolation = createNpmConfigIsolation(owner.staging, deps.inspectionDeps?.env);
// Include Windows temp/profile names: no npm or version cache may fall back to a live home.
const env = { ...isolation.env, HOME: owner.staging, USERPROFILE: owner.staging, TEMP: owner.staging,
TMP: owner.staging, TMPDIR: owner.staging, APPDATA: owner.staging, LOCALAPPDATA: owner.staging, CODEX_HOME: owner.staging };
const invoke = (args: readonly string[], policy: WindowsCliChildInvocation["policy"]) => run({
executable: evidence.node, args: windowsNpmExecutionArgs(evidence.npmCli, npmArgs(args, isolation)), cwd: isolation.dir, env, policy,
});
const archives: string[] = [];
for (const [index, artifact] of [artifacts.main, artifacts.backing].entries()) {
if (cancelled()) return finish("refused", "cancelled");
let path: string;
if (deps.fetchArtifact) {
path = win32.join(owner.staging, `${index}.tgz`);
writeFileSync(path, await deps.fetchArtifact(artifact, deps.signal), { flag: "wx" });
} else {
const packed = await invoke(["pack", `${artifact.name}@${artifact.version}`, "--json", "--ignore-scripts",
"--pack-destination", owner.staging, "--fetch-retries=0", "--fetch-timeout=120000"], "pack");
if (!packed.terminal) return finish("ambiguous", "installer_state_unknown");
if (cleanupPending) return finish("ambiguous", "child_cleanup_unverified");
if (packed.failed || packed.overflow || packed.exitCode !== 0) throw new Error("pack_failed");
const names = JSON.parse(packed.stdout);
if (!Array.isArray(names) || names.length !== 1 || !/^[A-Za-z0-9][A-Za-z0-9._-]*\.tgz$/.test(names[0]?.filename)) throw new Error("pack_unverified");
path = win32.join(owner.staging, names[0].filename);
}
if (cancelled()) return finish("refused", "cancelled");
archives.push(path);
}
const layout = await verifyWindowsCodexCliLayout(artifacts, archives[0]!, archives[1]!);
if (cancelled()) return finish("refused", "cancelled");
const original = await observeWindowsInstall(evidence.prefix);
const fresh = await plan();
if (!fresh.applicable) return finish("refused", fresh.refusal ?? "plan_refused");
if (fresh.planId !== planId) return finish("refused", "plan_changed");
if (cancelled()) return finish("refused", "cancelled");
const args = ["install", "-g", "--prefix", evidence.prefix, "--offline", "--ignore-scripts", "--omit=optional",
"--no-audit", "--no-fund", "--package-lock=false", "--update-notifier=false",
`${artifacts.main.installName}@file:${archives[0]}`, `${artifacts.backing.installName}@file:${archives[1]}`];
const invocation: WindowsCliChildInvocation = { executable: evidence.node,
args: windowsNpmExecutionArgs(evidence.npmCli, npmArgs(args, isolation)), cwd: isolation.dir, env, policy: "installer" };
const window = deps.commitWindow;
let nativeChild: WindowsCliChild | undefined;
let injectedInstall: Promise<{ terminal: boolean; exitCode: number | null }> | undefined;
if (window) {
installationWindowHeld = window.tryEnter() || await window.waitEnter();
if (!installationWindowHeld) return finish("refused", cancelled() ? "cancelled" : "installation_busy");
}
// Renew all observations after gate acquisition, including asynchronous ACLs.
// Acquisition is bounded; the Windows observation window is not short by guarantee.
if (cancelled()) return finish("refused", "cancelled");
await owner.authority.verify();
const before = await inspect(), selected = windowsCodexCliPlanEvidence(before);
if (!selected || JSON.stringify(selected) !== JSON.stringify(evidence)
|| before.installContentDigest !== initialPlan.installContentDigest
|| !sameWindowsInstall(original, await observeWindowsInstall(evidence.prefix))) return finish("refused", "installation_changed");
const scan = (deps.scanProcesses ?? scanCodexSessionProcesses)(deps.processIo ?? {});
if (scan.kind !== "observed") return finish("refused", "blocked_process_state_unknown");
if (scan.processes.length) return finish("refused", "blocked_active_session");
// No await from these held-identity/selection checks through CAS and native start.
owner.authority.verifyIdentitySync();
if (!windowsCodexCliSelectionMatches(before, inspection())) return finish("refused", "installation_changed");
if (cancelled() || (window && !window.commit())) return finish("refused", "cancelled");
installerStarted = true; // CAS is the irrevocable start decision, not spawn success.
uncertain = true;
// Trusted injection must begin its start synchronously, like native Create/Assign/Resume.
if (deps.install) injectedInstall = deps.install({ bin: invocation.executable,
args: invocation.args, cwd: invocation.cwd, env: invocation.env });
else nativeChild = startOwned(invocation);
const installed = nativeChild ? await settle(nativeChild) : await injectedInstall!;
uncertain = !installed.terminal; exitCode = installed.exitCode;
if (uncertain) return finish("ambiguous", "installer_state_unknown");
if (cleanupPending) return finish("ambiguous", "child_cleanup_unverified");
await owner.authority.verify();
const observed = await observeWindowsInstall(evidence.prefix);
const after = await inspect(), afterEvidence = windowsCodexCliPlanEvidence(after);
installedVersion = after.packageVersion;
const selectedAfter = after.managed && afterEvidence && afterEvidence.prefix === evidence.prefix
&& windowsCodexCliSelectionMatches(first, inspection())
&& afterEvidence.launcher === evidence.launcher && afterEvidence.nodeEvidence === evidence.nodeEvidence
&& afterEvidence.npmEvidence === evidence.npmEvidence;
if (!selectedAfter) return finish("ambiguous", "installation_readback_unverified");
if (after.packageVersion === targetVersion && sameWindowsPreservedEntries(original, observed)
&& expectedDirectories(layout.files, observed)
&& afterEvidence.backingRoot === win32.join(evidence.prefix, layout.backingRoot)
&& matchesWindowsCodexCliLayout(layout, observed.files.filter(file => windowsCodexOwnedPath(file.relativePath)))) {
const version = await run({ executable: evidence.node, args: [win32.join(evidence.prefix, layout.mainRoot, "bin/codex.js"), "--version"],
cwd: owner.staging, env, policy: "version" });
verificationPid = version.terminal ? null : owner.child?.pid ?? null;
if (!version.terminal) return finish("ambiguous", "version_process_state_unknown");
if (cleanupPending) return finish("ambiguous", "child_cleanup_unverified");
if (version.failed || version.overflow || version.exitCode !== 0 || version.stdout.trim() !== `codex-cli ${targetVersion}`) {
return finish("ambiguous", "version_readback_unverified");
}
const final = await inspect(); await owner.authority.verify();
if (!windowsCodexCliSelectionMatches(after, inspection()) || final.installContentDigest !== after.installContentDigest
|| !sameWindowsInstall(observed, await observeWindowsInstall(evidence.prefix))) {
return finish("ambiguous", "version_readback_unverified");
}
return finish("applied", "verified_target");
}
if (after.packageVersion === first.packageVersion && after.installContentDigest === first.installContentDigest
&& sameWindowsInstall(original, observed)) return finish("not_applied", "original_install_unchanged");
return finish("ambiguous", "installation_readback_unverified");
} catch (error) {
if (error instanceof WindowsCliToolchainCleanupError) {
deps.retainExecution?.(error.acquisition);
ownerRegistrationPending = true; cleanupPending = true;
return finish("ambiguous", "installer_or_readback_error");
}
if (!installerStarted && !uncertain && !ownerRegistrationPending && cancelled()) return finish("refused", "cancelled");
if (!installerStarted && !uncertain && !ownerRegistrationPending && error instanceof Error
&& ["cancelled", "installation_changed", "blocked_process_state_unknown", "blocked_active_session"].includes(error.message)) {
return finish("refused", error.message);
}
return finish(installerStarted || uncertain || ownerRegistrationPending ? "ambiguous" : "refused",
installerStarted || uncertain || ownerRegistrationPending ? "installer_or_readback_error" : "preparation_failed");
} finally {
recoveryAllowed = true;
// Readback (including the version child's descendants) is inside exclusion.
// Unknown lifetime retains the exact window instead of reopening parent paths.
if (installationWindowHeld && !uncertain && !cleanupPending) deps.commitWindow!.exit();
if (owner && !uncertain && !cleanupPending) {
const errors: CodexCliApplyCleanupError[] = [];
let resourcesReleased = true;
try {
await flushWindowsSecretAclReapsBeforeRemoval(owner.staging);
await owner.authority.removeStaging();
} catch { errors.push("staging_cleanup_failed"); resourcesReleased = false; }
try { if (owner.toolchain && !await owner.toolchain.release()) {
errors.push("lease_release_unverified"); resourcesReleased = false;
} }
catch { errors.push("lease_release_exception"); resourcesReleased = false; }
try { if (!await owner.authority.release()) errors.push("lease_release_unverified"); }
catch { errors.push("lease_release_exception"); }
resourcesReleased &&= owner.authority.resourcesReleased;
if (resourcesReleased) { retained.delete(owner); ownerRegistrationPending = false; owner.retention?.release(); }
if (output) Object.assign(output, { cleanupErrors: errors, leaseRetained: !resourcesReleased });
}
if (output) { Object.freeze(output.cleanupErrors); Object.freeze(output); }
}
}