@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
269 lines (262 loc) • 18.5 kB
text/typescript
import { createHash } from "node:crypto";
import { win32 } from "node:path";
import { parseStrictSemver } from "../lib/strict-semver";
import { npmCodexCommandShim } from "./cli-installation-identity";
import { MAX_NATIVE_BACKING_BYTES } from "./cli-installation-limits";
import { deriveCodexCliInstallationInput } from "./cli-installation-targets";
import type { CodexCliInstallProvenanceDeps, CodexCliInstallReport } from "./cli-install-provenance";
import { resolveCodexRuntime } from "./runtime";
import { inspectWindowsInstallationFiles as inspectFiles, type WindowsInstallationFilesResult } from "./windows-installation-files";
// Every plan observation refuses alternate names, including aliases of ancestors.
const inspectWindowsInstallationFiles: typeof inspectFiles = (requests, finalize) =>
inspectFiles(requests.map(request => ({ ...request, requireCanonicalPath: true })), finalize);
async function withCanonicalExclusionRoots<R>(roots: readonly string[], run: () => Promise<R>,
onRefusal?: (reason: Extract<WindowsInstallationFilesResult, { kind: "refused" }>["reason"]) => void): Promise<R | null> {
if (!roots.length) return run();
let result: R | null = null;
// Keep every exclusion open across the observation/query; validate each batch
// under the native reader's existing request ceiling without dropping a root.
const observed = await inspectWindowsInstallationFiles(roots.slice(0, 12).map(path => ({
path: win32.normalize(path), maxBytes: 0, metadataOnly: true, directory: true,
})), async () => {
result = await withCanonicalExclusionRoots(roots.slice(12), run, onRefusal); return result !== null;
});
if (observed.kind === "refused") onRefusal?.(observed.reason);
return observed.kind === "observed" ? result : null;
}
import { openWindowsCliToolchainAuthority, WindowsCliToolchainCleanupError } from "./cli-update-job-store-windows";
/** Private plan evidence. Explicit `attest` observations never enter this map. */
interface WindowsPlanEvidence { readonly node: string; readonly npmCli: string; readonly arch: "x64" | "arm64";
readonly prefix: string; readonly launcher: string; readonly backingRoot: string;
readonly envPath: string | undefined; readonly envPathExt: string | undefined;
readonly nodeEvidence: string; readonly npmEvidence: string; readonly exclusionRoots: readonly string[] }
const evidence = new WeakMap<CodexCliInstallReport, WindowsPlanEvidence>();
const toolchainDigests = new WeakMap<CodexCliInstallReport, string>();
type WindowsPlanRefusalGate = "selection" | "exclusion-roots" | "local-node" | "derivation"
| "launcher-arch" | "excluded-layout" | "initial-observation" | "initial-content"
| "backing-selection" | "final-observation" | "shim-content" | "manifest-identity"
| "node-identity" | "backing-content" | "exception";
type WindowsPlanRefusalReason = Extract<WindowsInstallationFilesResult, { kind: "refused" }>["reason"]
| Extract<Awaited<ReturnType<typeof deriveCodexCliInstallationInput>>, { kind: "unavailable" }>["reason"];
interface WindowsPlanRefusal { readonly gate: WindowsPlanRefusalGate; readonly reason?: WindowsPlanRefusalReason }
const refusals = new WeakMap<CodexCliInstallReport, WindowsPlanRefusal>();
/** Test diagnostics only: fixed codes, never paths, exception messages or public report fields. */
export const windowsCodexCliPlanRefusalForTests = (report: CodexCliInstallReport): WindowsPlanRefusal | null => refusals.get(report) ?? null;
export const windowsCodexCliToolchainDigest = (report: CodexCliInstallReport): string | undefined => toolchainDigests.get(report);
export const windowsCodexCliPlanEvidence = (report: CodexCliInstallReport): WindowsPlanEvidence | null => evidence.get(report) ?? null;
const hash = (value: string): string => createHash("sha256").update(value).digest("hex");
type File = Extract<WindowsInstallationFilesResult, { kind: "observed" }>["files"][number];
const id = (file: File): string => JSON.stringify([file.path, file.identity, file.digest]);
const sameWindowsPath = (left: string, right: string): boolean => win32.resolve(left).toLowerCase() === win32.resolve(right).toLowerCase();
function selectedWindowsOverride(candidate: string, env: NodeJS.ProcessEnv, configDir?: string): boolean {
return env.CODEX_CLI_PATH?.trim() === candidate && resolveCodexRuntime({ platform: "win32", env, configDir,
probeVersion: false, discoverAlternatives: false, existsSync: path => path === candidate,
readFileSync: () => { throw new Error("state not required for explicit override"); },
readdirSync: () => [], statSync: () => { throw new Error("discovery disabled"); },
}).runtime.command === candidate;
}
/** Synchronous selection fence after the last awaited authority check, before native start. */
export function windowsCodexCliSelectionMatches(report: CodexCliInstallReport, deps: CodexCliInstallProvenanceDeps): boolean {
const captured = evidence.get(report), env = deps.env;
return !!captured && !!env && deps.selectionAttested === true && env.PATH === captured.envPath
&& env.PATHEXT === captured.envPathExt && selectedWindowsOverride(captured.launcher, env, deps.configDir);
}
/** Metadata queries execute only while the observed Node/npm and ancestors deny replacement. */
export async function withWindowsCodexCliPlanToolchain<R>(report: CodexCliInstallReport,
run: () => R): Promise<Awaited<R> | null> {
const toolchain = evidence.get(report);
if (!toolchain) return null;
return withCanonicalExclusionRoots(toolchain.exclusionRoots, async () => {
let authority;
try { authority = await openWindowsCliToolchainAuthority(toolchain.node, win32.dirname(win32.dirname(toolchain.npmCli)), true); }
catch (error) { if (error instanceof WindowsCliToolchainCleanupError) throw error; return null; }
let result: Awaited<R> | null = null;
try { const observed = await inspectWindowsInstallationFiles([
{ path: toolchain.node, maxBytes: 128 * 1024 * 1024, hashOnly: true },
{ path: toolchain.npmCli, maxBytes: 256 * 1024 },
], async files => {
if (id(files[0]!) !== toolchain.nodeEvidence || id(files[1]!) !== toolchain.npmEvidence) return false;
toolchainDigests.set(report, authority.digest);
result = await run(); return true;
});
return observed.kind === "observed" ? result : null;
} finally { if (!await authority.release()) throw new Error("toolchain_release_unverified"); }
});
}
/** Transfer a held toolchain observation to a transaction, including unknown child lifetimes. */
export async function holdWindowsCodexCliPlanToolchain(report: CodexCliInstallReport) {
const toolchain = evidence.get(report);
if (!toolchain) return null;
let authority;
try { authority = await openWindowsCliToolchainAuthority(toolchain.node, win32.dirname(win32.dirname(toolchain.npmCli)), true); }
catch (error) { if (error instanceof WindowsCliToolchainCleanupError) throw error; return null; }
const admitted = Promise.withResolvers<boolean>();
const release = Promise.withResolvers<void>();
const observing = withCanonicalExclusionRoots(toolchain.exclusionRoots, () => inspectWindowsInstallationFiles([
{ path: toolchain.node, maxBytes: 128 * 1024 * 1024, hashOnly: true },
{ path: toolchain.npmCli, maxBytes: 256 * 1024 },
], async files => {
if (id(files[0]!) !== toolchain.nodeEvidence || id(files[1]!) !== toolchain.npmEvidence) return false;
admitted.resolve(true);
await release.promise;
return true;
}));
void observing.then(() => admitted.resolve(false), () => admitted.resolve(false));
if (!await admitted.promise) { await authority.release(); return null; }
return { async release() { release.resolve(); const observed = await observing;
return await authority.release() && observed?.kind === "observed"; } };
}
const json = (file: File): Record<string, unknown> | null => {
try { const item = JSON.parse(Buffer.from(file.bytes).toString("utf8"));
return item && typeof item === "object" && !Array.isArray(item) ? item : null;
} catch { return null; }
};
const entry = (item: Record<string, unknown>, name: string): unknown => typeof item.bin === "string" ? item.bin
: item.bin && typeof item.bin === "object" ? (item.bin as Record<string, unknown>)[name] : null;
function peArch(bytes: Uint8Array): "x64" | "arm64" | null {
const b = Buffer.from(bytes);
if (b.length < 64 || b.toString("ascii", 0, 2) !== "MZ") return null;
const offset = b.readUInt32LE(60);
if (offset > b.length - 6 || b.toString("ascii", offset, offset + 4) !== "PE\0\0") return null;
return b.readUInt16LE(offset + 4) === 0x8664 ? "x64" : b.readUInt16LE(offset + 4) === 0xaa64 ? "arm64" : null;
}
/**
* Read-only supported subset: a proof-captured absolute standard npm cmd-shim
* override, its global-prefix package, a held-bound Node/npm toolchain, and the
* in-prefix optional backing. When the prefix has no node.exe, the toolchain is
* the npm pair the captured PATH resolves — the updater's own metadata vehicle,
* never a claim about which interpreter a later codex.cmd invocation resolves:
* the shim's bare `node` falls through to the ambient invocation working
* directory, which no launcher snapshot can prove. A separate toolchain
* therefore also requires the launcher arch anchor, keeping the backing lane
* tied to the selection instead of to an arbitrary PATH hit.
*/
export async function inspectWindowsCodexCliPlanInstall(
deps: CodexCliInstallProvenanceDeps, fallback: CodexCliInstallReport, excluded: (path: string) => boolean,
exclusionRoots: readonly string[] = [],
): Promise<CodexCliInstallReport> {
const refuse = (gate: WindowsPlanRefusalGate, reason?: WindowsPlanRefusalReason): CodexCliInstallReport => {
refusals.set(fallback, Object.freeze(reason === undefined ? { gate } : { gate, reason }));
return fallback;
};
const env = deps.env ?? {};
const candidate = env.CODEX_CLI_PATH?.trim();
if (!deps.selectionAttested || !candidate || !/^[a-z]:[\\/]/i.test(candidate)
|| win32.basename(candidate) !== "codex.cmd"
|| (deps.selectedCommand != null && deps.selectedCommand !== candidate)) return refuse("selection");
if (exclusionRoots.length) {
const roots = Object.freeze([...exclusionRoots]);
let reason: WindowsPlanRefusalReason | undefined;
const report = await withCanonicalExclusionRoots(roots,
() => inspectWindowsCodexCliPlanInstall(deps, fallback, excluded), value => { reason ??= value; });
if (report) {
const toolchain = evidence.get(report);
if (toolchain) evidence.set(report, Object.freeze({ ...toolchain, exclusionRoots: roots }));
}
return report ?? refuse("exclusion-roots", reason);
}
// The bounded content read is opt-in: a bare ownership check holds the same
// reparse-refusing handles; only bounded ownership/header reads remain.
const observe = deps.observeInstallContent === true;
const prefix = win32.dirname(candidate);
const localNodePath = win32.join(prefix, "node.exe");
const localNode = await inspectWindowsInstallationFiles([{ path: localNodePath, maxBytes: 0, metadataOnly: true }]);
if (localNode.kind === "refused" && localNode.reason !== "not-found") return refuse("local-node", localNode.reason);
const selectedPath = env.PATH;
const selectedPathExt = env.PATHEXT;
const derivation = await deriveCodexCliInstallationInput({
codexCliPath: candidate, path: selectedPath ?? null, pathExt: selectedPathExt ?? null,
}, { platform: "win32" });
if (derivation.kind !== "derived" || derivation.input.candidate !== candidate
|| derivation.input.npmPrefix !== prefix) return refuse("derivation", derivation.kind === "unavailable" ? derivation.reason : undefined);
const node = derivation.input.node;
const npmCli = derivation.input.npmCli;
const npmRoot = win32.dirname(win32.dirname(npmCli));
const pathNode = !sameWindowsPath(node, localNodePath);
// A prefix-local node.exe is provably the shim's own interpreter; a PATH-resolved
// separate toolchain is bound as the updater's metadata vehicle only. Without the
// launcher arch the toolchain's arch cannot be tied to the selection at all, so a
// separate toolchain stays refused rather than claim an unanchored backing lane.
if (pathNode && !deps.arch) return refuse("launcher-arch");
const root = win32.join(prefix, "node_modules", "@openai", "codex");
const manifest = win32.join(root, "package.json");
const npmManifest = win32.join(npmRoot, "package.json");
const bin = win32.join(root, "bin", "codex.js");
const paths = [candidate, node, npmCli, root];
if (prefix === win32.parse(prefix).root || paths.some(excluded)) return refuse("excluded-layout");
// Only already handle-observed files can pass the real resolver's existence
// predicate. The explicit override wins before saved-state/shim/PATH candidates.
const selected = () => selectedWindowsOverride(candidate, env, deps.configDir);
try {
const first = await inspectWindowsInstallationFiles([
{ path: manifest, maxBytes: 256 * 1024 }, { path: npmManifest, maxBytes: 256 * 1024 },
{ path: node, maxBytes: 4096, prefixOnly: true },
]);
if (first.kind !== "observed") return refuse("initial-observation", first.reason);
const initial = new Map(first.files.map(file => [file.path, file]));
const main = json(initial.get(manifest)!); const npm = json(initial.get(npmManifest)!);
const arch = peArch(initial.get(node)!.bytes);
if (!main || main.name !== "@openai/codex" || typeof main.version !== "string" || !parseStrictSemver(main.version)
|| entry(main, "codex") !== "bin/codex.js" || !npm || npm.name !== "npm"
|| typeof npm.version !== "string" || !parseStrictSemver(npm.version) || entry(npm, "npm") !== "bin/npm-cli.js"
|| !arch || (deps.arch && deps.arch !== arch)) return refuse("initial-content");
const pkg = `@openai/codex-win32-${arch}`;
const triple = arch === "x64" ? "x86_64-pc-windows-msvc" : "aarch64-pc-windows-msvc";
// Node's nearest-first package lookup, bounded to this independent prefix.
const lanes = [win32.join(root, "bin", "node_modules"), win32.join(root, "node_modules"),
win32.join(prefix, "node_modules", "@openai", "node_modules"), win32.join(prefix, "node_modules")];
let backingRefusal: WindowsPlanRefusalReason | undefined;
const backingSelection = async (): Promise<string | null> => {
for (const lane of lanes) {
const path = win32.join(lane, pkg, "package.json");
const probe = await inspectWindowsInstallationFiles([{ path, maxBytes: 0, metadataOnly: true }]);
if (probe.kind === "observed") return path;
if (probe.reason !== "not-found") { backingRefusal = probe.reason; return null; }
}
return null; // No global module lookup or vendor fallback adoption.
};
const backingManifest = await backingSelection();
if (!backingManifest) return refuse("backing-selection", backingRefusal ?? "not-found");
const native = win32.join(win32.dirname(backingManifest), "vendor", triple, "bin", "codex.exe");
// Ownership requires the manifests, shim and backing manifest bytes plus the
// bounded Node header read above; entrypoint, npm CLI, Node and native
// contents only feed the opt-in digest, so they stay metadata-held without it.
const owned = (path: string) => ({ path, maxBytes: 256 * 1024 });
const bound = (path: string) => observe ? { path, maxBytes: 256 * 1024 } : { path, maxBytes: 0, metadataOnly: true };
const requests = [owned(manifest), owned(npmManifest), owned(candidate), bound(bin), bound(npmCli), owned(backingManifest)];
const final = await inspectWindowsInstallationFiles([...requests,
observe
? { path: node, maxBytes: 128 * 1024 * 1024, hashOnly: true }
: { path: node, maxBytes: 0, metadataOnly: true },
observe
? { path: native, maxBytes: MAX_NATIVE_BACKING_BYTES, hashOnly: true }
: { path: native, maxBytes: 0, metadataOnly: true },
], async () => selected() && env.PATH === selectedPath && env.PATHEXT === selectedPathExt
&& await deriveCodexCliInstallationInput({ codexCliPath: candidate,
path: selectedPath ?? null, pathExt: selectedPathExt ?? null }, { platform: "win32" })
.then(current => current.kind === "derived" && current.input.candidate === candidate
&& current.input.npmPrefix === prefix && current.input.node === node && current.input.npmCli === npmCli)
&& await backingSelection() === backingManifest);
if (final.kind !== "observed") return refuse("final-observation", backingRefusal ?? final.reason);
const files = new Map(final.files.map(file => [file.path, file]));
if (!npmCodexCommandShim(files.get(candidate)!.bytes)) return refuse("shim-content");
for (const path of [manifest, npmManifest]) if (id(initial.get(path)!) !== id(files.get(path)!)) return refuse("manifest-identity");
if (JSON.stringify(initial.get(node)!.identity) !== JSON.stringify(files.get(node)!.identity)) return refuse("node-identity");
const backing = json(files.get(backingManifest)!);
if (!backing || "exports" in backing || ![pkg, "@openai/codex"].includes(String(backing.name))
|| ![main.version, `${main.version}-win32-${arch}`].includes(String(backing.version))) return refuse("backing-content");
const content = observe ? hash(JSON.stringify(["windows-npm-read-only-plan-v3", arch, prefix, candidate, node, npmCli,
...final.files.map(file => [file.path, file.identity, file.digest])])) : null;
const report: CodexCliInstallReport = Object.freeze({ ...fallback, managed: true, selectionAttested: true,
provenance: "npm-global", reason: "managed_npm_global", packageVersion: main.version,
versionEvidence: Object.freeze({ kind: "package-manifest" }), installDigest: hash(prefix),
installContentDigest: content, shim: Object.freeze({ status: "not-tracked", backingKind: null }),
evidence: Object.freeze(["package_manifest", "package_manifest_digest",
...(content ? ["install_content_digest" as const] : []), "global_npm_layout"] as const),
});
evidence.set(report, Object.freeze({ node, npmCli, arch, prefix, launcher: candidate,
envPath: selectedPath, envPathExt: selectedPathExt,
backingRoot: win32.dirname(backingManifest), nodeEvidence: id(files.get(node)!), npmEvidence: id(files.get(npmCli)!), exclusionRoots: Object.freeze([]) }));
return report;
} catch { return refuse("exception"); }
}