UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

142 lines (131 loc) • 6.72 kB
import { spawnSync } from "node:child_process"; import { randomUUID } from "node:crypto"; import { lstatSync, mkdirSync, readdirSync, rmdirSync } from "node:fs"; import { join } from "node:path"; import type { DurableBunRuntime } from "./bun-runtime"; export type RuntimePreflightReason = "spawn" | "timeout" | "create" | "remove" | "protocol"; export const RUNTIME_PREFLIGHT_TIMEOUT_MS = 5_000; export const RUNTIME_PREFLIGHT_GUIDANCE = "The selected Bun runtime could not create and remove a directory in the OpenCodex config directory. " + "Windows application policy may deny writes from this executable location. " + "Set OPENCODEX_BUN_PATH to a trusted Bun executable allowed by your policy before launching ocx, " + "or reinstall opencodex with npm install -g --allow-scripts=bun @bitkyc08/opencodex, then retry. No alternate runtime was selected."; export class RuntimePreflightError extends Error { readonly code = "OCX_RUNTIME_PREFLIGHT_FAILED"; constructor(readonly reason: RuntimePreflightReason) { super(`${RUNTIME_PREFLIGHT_GUIDANCE} (preflight: ${reason})`); this.name = "RuntimePreflightError"; } } // bigint: NTFS file IDs exceed 2^53, where adjacent IDs are equal as numbers. type DirectoryIdentity = { dev: bigint; ino: bigint; isDirectory(): boolean; isSymbolicLink(): boolean }; export interface RuntimePreflightFs { lstatSync: (path: string, options: { bigint: true }) => DirectoryIdentity; mkdirSync: (path: string, mode: number) => unknown; rmdirSync: (path: string) => void; readdirSync: (path: string) => readonly string[]; } export interface RuntimePreflightOptions { platform?: NodeJS.Platform; rootWasAbsent?: boolean; spawnSync?: typeof spawnSync; fs?: RuntimePreflightFs; nonce?: () => string; } /** Caller seams keep one selection through admission, rendering and state publication. */ export interface RuntimePreflightDeps { selectRuntime?: () => DurableBunRuntime; assertRuntimeWritable?: typeof assertSelectedRuntimeWritable; configDir?: () => string; platform?: NodeJS.Platform; } const probeFs: RuntimePreflightFs = { lstatSync, mkdirSync, rmdirSync, readdirSync }; function sameDirectory(fs: RuntimePreflightFs, path: string, owned: DirectoryIdentity): boolean { const current = fs.lstatSync(path, { bigint: true }); return current.isDirectory() && !current.isSymbolicLink() && current.dev === owned.dev && current.ino === owned.ino; } function removeOwnedEmptyDirectory(fs: RuntimePreflightFs, path: string, owned: DirectoryIdentity): void { try { if (sameDirectory(fs, path, owned) && fs.readdirSync(path).length === 0 && sameDirectory(fs, path, owned)) fs.rmdirSync(path); } catch { /* Never delete contents or a replacement; cleanup does not mask refusal. */ } } function prepareRoot(fs: RuntimePreflightFs, root: string, rootWasAbsent?: boolean): void { try { if (rootWasAbsent === undefined) { try { fs.lstatSync(root, { bigint: true }); rootWasAbsent = false; } catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; rootWasAbsent = true; } } if (rootWasAbsent) { try { fs.mkdirSync(root, 0o700); // Exclusive, non-recursive: a missing parent refuses. } catch (error) { if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error; // Use a concurrently created root, subject to the directory check below. } } const current = fs.lstatSync(root, { bigint: true }); if (!current.isDirectory() || current.isSymbolicLink()) throw new RuntimePreflightError("create"); } catch { throw new RuntimePreflightError("create"); } } function probeInProcess(fs: RuntimePreflightFs, path: string): void { let owned: DirectoryIdentity | undefined; try { try { fs.mkdirSync(path, 0o700); owned = fs.lstatSync(path, { bigint: true }); } catch { throw new RuntimePreflightError("create"); } try { fs.rmdirSync(path); } catch { throw new RuntimePreflightError("remove"); } } finally { if (owned) removeOwnedEmptyDirectory(fs, path, owned); } } function probeChild(runtime: DurableBunRuntime, path: string, nonce: string, spawn: typeof spawnSync): void { // The child emits only this invocation's nonce and a fixed result, never paths/errors. const script = `const fs = require("node:fs"); const path = ${JSON.stringify(path)}; let result = "create", owned; try { fs.mkdirSync(path, 0o700); owned = fs.lstatSync(path, { bigint: true }); result = "remove"; fs.rmdirSync(path); result = "ok"; } catch { /* result already names the failed step; details never leave the child */ } finally { if (owned) { try { const now = fs.lstatSync(path, { bigint: true }); if (now.isDirectory() && !now.isSymbolicLink() && now.dev === owned.dev && now.ino === owned.ino && fs.readdirSync(path).length === 0) fs.rmdirSync(path); } catch { /* leave any probe entry that cannot be proven ours */ } } } process.stdout.write(${JSON.stringify(nonce)} + ":" + result); process.exitCode = result === "ok" ? 0 : 1;`; let child: ReturnType<typeof spawnSync>; try { child = spawn(runtime.path, ["-e", script], { shell: false, windowsHide: true, timeout: RUNTIME_PREFLIGHT_TIMEOUT_MS, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 1024, }); } catch { throw new RuntimePreflightError("spawn"); } if (child.error) { throw new RuntimePreflightError((child.error as NodeJS.ErrnoException).code === "ETIMEDOUT" ? "timeout" : "spawn"); } const ack = String(child.stdout ?? ""); if (ack === `${nonce}:create` && child.status === 1) throw new RuntimePreflightError("create"); if (ack === `${nonce}:remove` && child.status === 1) throw new RuntimePreflightError("remove"); if (ack !== `${nonce}:ok` || child.status !== 0) throw new RuntimePreflightError("protocol"); } /** Windows admission of ONLY the already selected runtime. No discovery or memoization. */ export function assertSelectedRuntimeWritable( runtime: DurableBunRuntime, configDir: string, deps: RuntimePreflightOptions = {}, ): void { if ((deps.platform ?? process.platform) !== "win32") return; if (runtime.source === "standalone" && runtime.path !== process.execPath) throw new RuntimePreflightError("protocol"); const fs = deps.fs ?? probeFs; // The config root is durable: never delete it by pathname, even on refusal. prepareRoot(fs, configDir, deps.rootWasAbsent); const nonce = (deps.nonce ?? randomUUID)(); const path = join(configDir, `.ocx-runtime-probe-${nonce}`); if (runtime.source === "standalone") probeInProcess(fs, path); else probeChild(runtime, path, nonce, deps.spawnSync ?? spawnSync); }