@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
261 lines (255 loc) • 15.4 kB
text/typescript
import { win32 } from "node:path";
import { ptr } from "bun:ffi";
import { securityAttributes, wide, WIN64_CHILD_ABI, WindowsChildNative } from "./windows-cli-child-native";
import { WindowsChildPipe } from "./windows-cli-child-pipe";
import { startWindowsCliRecoveryGuardian } from "./windows-cli-recovery-guardian";
import type { CodexCliUpdateNativeRecoveryProof } from "./cli-update-recovery";
export type WindowsCliChildPolicy = "installer" | "pack" | "version";
export function windowsCliChildPolicy(policy: WindowsCliChildPolicy) {
switch (policy) {
case "installer": return { captureBytes: 0, deadlineMs: null, reapMs: null, terminate: false } as const;
case "pack": return { captureBytes: 1024 * 1024, deadlineMs: null, reapMs: null, terminate: false } as const;
case "version": return { captureBytes: 16 * 1024, deadlineMs: 8000, reapMs: 1000, terminate: true } as const;
}
}
export interface WindowsCliChildInvocation {
readonly executable: string;
readonly args: readonly string[];
readonly cwd: string;
readonly env: Readonly<NodeJS.ProcessEnv>;
readonly policy: WindowsCliChildPolicy;
/** Private durable recovery identity, selected before native creation. */
readonly recoveryJobName?: string;
readonly recoveryProof?: CodexCliUpdateNativeRecoveryProof;
}
export interface WindowsCliChildResult {
readonly terminal: boolean;
/** Terminal process/Job accounting does not establish successful handle disposal. */
readonly cleanupComplete: boolean;
readonly exitCode: number | null;
readonly stdout: string;
readonly overflow: boolean;
readonly failed: boolean;
readonly reason: string | null;
}
/** CRT argv quoting, with explicit lpApplicationName; never cmd.exe or PATH lookup. */
export function quoteWindowsChildArg(arg: string): string {
return '"' + arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, '$1$1') + '"';
}
function validate(invocation: WindowsCliChildInvocation): void {
const localAbsolute = (value: string) => typeof value === "string" && /^[A-Za-z]:[\\/]/.test(value)
&& win32.isAbsolute(value) && !value.includes("\0");
if (!localAbsolute(invocation.executable) || !/\.exe$/i.test(invocation.executable)
|| !localAbsolute(invocation.cwd) || !Array.isArray(invocation.args)
|| invocation.args.some(arg => typeof arg !== "string" || arg.includes("\0"))
|| !windowsCliChildPolicy(invocation.policy)
|| (invocation.recoveryJobName !== undefined && !/^Global\\ocx-cli-[0-9a-f-]{36}$/.test(invocation.recoveryJobName))) throw new Error("windows_child_invalid_invocation");
}
function environmentBlock(env: Readonly<NodeJS.ProcessEnv>, native: WindowsChildNative): Buffer {
const entries = Object.keys(env).filter(key => env[key] !== undefined).map(key => {
const value = env[key]!;
if (!key || /[=\0]/.test(key) || value.includes("\0")) throw new Error("windows_child_invalid_environment");
return { key: wide(key), entry: `${key}=${value}` };
});
// Windows requires case-insensitive ordinal sorting, independent of JS/host locale.
const compare = (a: typeof entries[number], b: typeof entries[number]) => {
const result = Number(native.k.CompareStringOrdinal!(ptr(a.key), -1, ptr(b.key), -1, 1));
if (!result) throw new Error("windows_child_environment_compare_failed");
return result - 2;
};
entries.sort(compare);
for (let i = 1; i < entries.length; i++) if (compare(entries[i - 1]!, entries[i]!) === 0) throw new Error("windows_child_invalid_environment");
return Buffer.from(entries.map(item => item.entry).join("\0") + "\0\0", "utf16le");
}
/**
* Owns an unnamed non-inheritable Job and the original primary process handle.
* No KILL_ON_JOB_CLOSE, active-process limit, BREAKAWAY, PID reopen, or running abort.
* A caller must adopt lease/staging ownership BEFORE calling start, and retain this
* object and those resources whenever wait() returns terminal:false.
*/
export class WindowsCliChild {
readonly pipe: WindowsChildPipe;
readonly policy: ReturnType<typeof windowsCliChildPolicy>;
readonly startedAt = Date.now();
private readonly clockStartedAt = performance.now();
pid: number | null = null;
creationTime: string | null = null;
process = 0n;
job = 0n;
recoveryGuardian = 0n;
setupFailure: string | null = null;
private stopAt: number | null = null;
private terminationFailed = false;
private failed = false;
private reason: string | null = null;
private overflow = false;
private chunks: Buffer[] = [];
private captured = 0;
private waiting = false;
private finished: WindowsCliChildResult | undefined;
private observedTerminal: { terminal: true; exitCode: number; unknown: false } | undefined;
private prestartTerminationFailed = false;
constructor(readonly native: WindowsChildNative, policy: WindowsCliChildPolicy) {
this.policy = windowsCliChildPolicy(policy); this.pipe = new WindowsChildPipe(native);
}
private fail(reason: string): void { this.failed = true; this.reason ??= reason; }
private consume = (bytes: Buffer): void => {
const remaining = this.policy.captureBytes - this.captured;
if (bytes.length > remaining && this.policy.captureBytes) this.overflow = true;
if (remaining > 0) { const chunk = Buffer.from(bytes.subarray(0, remaining)); this.chunks.push(chunk); this.captured += chunk.length; }
// Overflow still drains/discards. Only the separate version policy may stop a Job.
if (this.overflow && this.policy.terminate) this.stop("output_limit");
};
private stop(reason: string): void {
this.fail(reason);
if (this.stopAt !== null || !this.policy.terminate) return;
this.stopAt = performance.now();
if (!this.native.k.TerminateJobObject!(this.job, 1)) this.terminationFailed = true;
}
private result(terminal: boolean, exitCode: number | null): WindowsCliChildResult {
return { terminal, cleanupComplete: terminal && this.native.handles.size === 0 && this.native.borrowedMemory.size === 0,
exitCode, stdout: Buffer.concat(this.chunks, this.captured).toString("utf8"),
overflow: this.overflow, failed: this.failed || !!this.setupFailure, reason: this.setupFailure ?? this.reason };
}
/** A successful accounting query plus a signaled original process handle, never PID absence or STILL_ACTIVE. */
observe(): { terminal: boolean; exitCode: number | null; unknown: boolean } {
if (this.observedTerminal) return this.observedTerminal;
const k = this.native.k, accounting = Buffer.alloc(WIN64_CHILD_ABI.jobAccounting), code = Buffer.alloc(4);
const wait = Number(k.WaitForSingleObject!(this.process, 0));
if (wait !== 0 && wait !== 258) { this.fail("process_wait_failed"); return { terminal: false, exitCode: null, unknown: true }; }
if (!k.QueryInformationJobObject!(this.job, 1, ptr(accounting), accounting.length, null)) {
this.fail("job_query_failed"); return { terminal: false, exitCode: null, unknown: true };
}
if (wait !== 0 || accounting.readUInt32LE(40) !== 0) return { terminal: false, exitCode: null, unknown: false };
if (!k.GetExitCodeProcess!(this.process, ptr(code))) {
this.fail("process_exit_query_failed"); return { terminal: false, exitCode: null, unknown: true };
}
return this.observedTerminal = { terminal: true, exitCode: code.readUInt32LE(), unknown: false };
}
async wait(): Promise<WindowsCliChildResult> {
if (this.finished) return this.finished;
if (!this.process) throw new Error("windows_child_not_created_use_cleanup");
if (this.waiting) throw new Error("windows_child_wait_already_owned");
this.waiting = true;
try {
for (;;) {
this.pipe.pump(this.consume);
if (this.pipe.error) { this.fail("pipe_read_failed"); if (this.policy.terminate) this.stop("pipe_read_failed"); }
const observed = this.observe();
if (observed.terminal && this.pipe.eof) {
if (this.recoveryGuardian) {
const wait = Number(this.native.k.WaitForSingleObject!(this.recoveryGuardian, 0));
if (wait === 258) {
if (this.policy.deadlineMs !== null && performance.now() - this.clockStartedAt
>= this.policy.deadlineMs + this.policy.reapMs!) {
this.fail("recovery_observer_state_unknown"); return this.result(false, null);
}
await Bun.sleep(5); continue;
}
if (wait !== 0) { this.fail("recovery_observer_wait_failed"); return this.result(false, null); }
this.native.close(this.recoveryGuardian);
}
await this.pipe.dispose();
this.native.close(this.process); this.native.close(this.job);
const released = this.native.dispose();
if (!released) this.fail("handle_close_failed");
return this.finished = this.result(true, observed.exitCode);
}
if (observed.unknown || this.terminationFailed || this.prestartTerminationFailed
|| (this.pipe.error && this.pipe.pending)) return this.result(false, null);
if (this.policy.deadlineMs !== null && performance.now() - this.clockStartedAt >= this.policy.deadlineMs) this.stop("deadline");
if (this.stopAt !== null && performance.now() - this.stopAt >= this.policy.reapMs!) return this.result(false, null);
await Bun.sleep(5);
}
} finally { this.waiting = false; }
}
/** Not a running-child disposal API: only pre-user-code setup failures may call it. */
reapUnstarted(): boolean {
if (!this.setupFailure || !this.process || this.finished || !this.native.handles.has(this.process)) return false;
this.prestartTerminationFailed = !this.native.k.TerminateProcess!(this.process, 1);
return !this.prestartTerminationFailed;
}
}
export function startWindowsCliChild(invocation: WindowsCliChildInvocation): WindowsCliChild {
validate(invocation);
return startWindowsCliChildWithNative(invocation, new WindowsChildNative());
}
/** Internal native dispatch seam; fixtures use the real APIs with single-call faults. */
export function startWindowsCliChildWithNative(invocation: WindowsCliChildInvocation, native: WindowsChildNative): WindowsCliChild {
validate(invocation);
const child = new WindowsCliChild(native, invocation.policy), k = native.k;
let stdin = 0n, stderr = 0n, thread = 0n, attributes: Buffer | undefined, initialized = false;
let inheritedHandles: Buffer | undefined;
try {
if (invocation.recoveryJobName) {
const name = wide(invocation.recoveryJobName), descriptor = native.privateDescriptor();
try {
const security = securityAttributes(false, descriptor);
k.SetLastError!(0);
child.job = native.keep(k.CreateJobObjectW!(ptr(security), ptr(name)));
// Never adopt a pre-existing object, even inside the current-user boundary.
if (k.GetLastError!() === 183) throw new Error("windows_child_job_exists");
} finally { k.LocalFree!(descriptor); }
} else child.job = native.keep(k.CreateJobObjectW!(null, null));
child.pipe.open();
const inheritable = securityAttributes(true), nul = wide("NUL");
stdin = native.keep(k.CreateFileW!(ptr(nul), 0x80000000, 3, ptr(inheritable), 3, 0, 0n));
stderr = native.keep(k.CreateFileW!(ptr(nul), 0x40000000, 3, ptr(inheritable), 3, 0, 0n));
const handles = inheritedHandles = Buffer.alloc(24);
[stdin, child.pipe.child, stderr].forEach((handle, index) => handles.writeBigUInt64LE(handle, index * 8));
const size = Buffer.alloc(8);
k.InitializeProcThreadAttributeList!(null, 1, 0, ptr(size));
const length = Number(size.readBigUInt64LE());
if (length < 24 || length > 1024 * 1024) throw new Error("attribute_size");
attributes = Buffer.alloc(length);
native.borrowedMemory.add(attributes); native.borrowedMemory.add(handles);
if (!k.InitializeProcThreadAttributeList!(ptr(attributes), 1, 0, ptr(size))) throw new Error("attribute_init");
initialized = true;
if (!k.UpdateProcThreadAttribute!(ptr(attributes), 0, 0x20002n, ptr(handles), 24n, null, null)) throw new Error("attribute_handles");
const startup = Buffer.alloc(WIN64_CHILD_ABI.startupInfoEx), info = Buffer.alloc(WIN64_CHILD_ABI.processInformation);
startup.writeUInt32LE(startup.length); startup.writeUInt32LE(0x100, 60);
[stdin, child.pipe.child, stderr].forEach((handle, index) => startup.writeBigUInt64LE(handle, 80 + index * 8));
startup.writeBigUInt64LE(BigInt(ptr(attributes)), 104);
const executable = wide(invocation.executable), command = wide([invocation.executable, ...invocation.args].map(quoteWindowsChildArg).join(" "));
const cwd = wide(invocation.cwd), env = environmentBlock(invocation.env, native);
if (command.length > 65534) throw new Error("command_length");
// CREATE_SUSPENDED | CREATE_UNICODE_ENVIRONMENT | EXTENDED_STARTUPINFO_PRESENT | CREATE_NO_WINDOW.
// All buffers above remain strongly reachable through CreateProcessW and attribute deletion.
if (!k.CreateProcessW!(ptr(executable), ptr(command), null, null, 1, 0x08080404, ptr(env), ptr(cwd), ptr(startup), ptr(info))) {
throw new Error(`create_process_${k.GetLastError!()}`);
}
child.process = native.keep(info.readBigUInt64LE(0)); thread = native.keep(info.readBigUInt64LE(8));
child.pid = info.readUInt32LE(16);
// Separate FILETIME buffers: creating Buffer subarrays while evaluating FFI
// arguments can materialize a new backing store in bundled Bun on Windows.
const creation = Buffer.alloc(8), exit = Buffer.alloc(8), kernel = Buffer.alloc(8), user = Buffer.alloc(8);
if (!k.GetProcessTimes!(child.process, ptr(creation), ptr(exit), ptr(kernel), ptr(user))) throw new Error("process_times");
child.creationTime = creation.readBigUInt64LE().toString();
if (child.creationTime === "0") throw new Error("process_creation_time_unknown");
if (!k.AssignProcessToJobObject!(child.job, child.process)) throw new Error("job_assignment");
if (invocation.recoveryProof) child.recoveryGuardian = startWindowsCliRecoveryGuardian(native, child.job, invocation.recoveryProof, invocation.cwd);
if (Number(k.ResumeThread!(thread)) !== 1) throw new Error("resume_thread");
} catch (error) {
child.setupFailure = error instanceof Error ? error.message : "setup_failed";
if (child.process) child.reapUnstarted();
} finally {
if (initialized) k.DeleteProcThreadAttributeList!(ptr(attributes!));
if (attributes) native.borrowedMemory.delete(attributes);
if (inheritedHandles) native.borrowedMemory.delete(inheritedHandles);
child.pipe.closeChild();
if (stdin) native.close(stdin); if (stderr) native.close(stderr); if (thread) native.close(thread);
}
// No await has occurred while any parent-owned inheritable stdio handle was open.
if (!child.process) {
// No I/O read is issued until wait(). The connect call is the only possible pending operation.
// Caller receives the owner for async cancellation/settlement via cleanupUnstartedWindowsChild.
return child;
}
return child;
}
/** Setup never launched user code. Preserve owner until pending connect I/O is settled. */
export async function cleanupUnstartedWindowsChild(child: WindowsCliChild): Promise<boolean> {
if (child.process || !child.setupFailure) return false;
await child.pipe.dispose(); if (child.job) child.native.close(child.job);
return child.native.dispose();
}