UNPKG

@bitkyc08/opencodex

Version:

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

145 lines (139 loc) • 7.75 kB
/** * Wrapper write and ownership fingerprint for the Codex autostart shim. * * Extracted from shim.ts so the parent module stays inside the file-size * ratchet. This cluster is a closed dependency edge: everything here flows * from node:fs/node:path, the shim template builders, and the fingerprint * probes — nothing imports back into shim.ts. */ import { randomUUID } from "node:crypto"; import { chmodSync, lstatSync, renameSync, unlinkSync, writeFileSync } from "node:fs"; import { basename, dirname, join } from "node:path"; import { durableBunRuntime, type BunRuntimeSource, type DurableBunRuntime } from "../lib/bun-runtime"; import { sameFileIdentity, type FileIdentity } from "../lib/file-identity"; import { serviceApiTokenFilePath } from "../lib/service-secrets"; import { assertLegacyShimMutationAllowed } from "./shim-legacy-record"; import { buildUnixCodexShim, buildWindowsCodexShim, buildWindowsPowerShellCodexShim, gitBashPath, SHIM_MARKER, } from "./shim-templates"; import { sameFingerprint, stableShimPathProbe, type ShimPathFingerprint, type StableShimPathProbe, } from "./shim-fingerprint"; function cliEntry(runtime: DurableBunRuntime = durableBunRuntime()): { bun: string; bunRuntimeSource: BunRuntimeSource; cli: string } { // Bundled Bun path (survives `ocx update`); all three shim builders // (Unix / Windows cmd / Windows PowerShell) receive it via this entry. // This module lives in src/codex/, the CLI entry in src/cli/index.ts. // Path and provenance resolve together so the marker always describes this binary. return { bun: runtime.path, bunRuntimeSource: runtime.source, cli: join(import.meta.dir, "..", "cli", "index.ts") }; } /** * Write the wrapper and return the identity of the inode this call created, or * `undefined` where the platform still writes the destination in place. * * Callers must derive ownership from the returned identity rather than from a * later `stat` of `wrapperPath`: the shim markers are public, so a concurrent * updater's wrapper can carry them, and a replacement landing between the write * and the observation is otherwise indistinguishable from our own file. */ /** The Windows wrapper for `wrapperPath`'s flavor (.ps1, .cmd/.bat, or extensionless Git-Bash sh). */ export function windowsShimContent(wrapperPath: string, realCodexPath: string, runtime?: DurableBunRuntime): string { const { bun, bunRuntimeSource, cli } = cliEntry(runtime); const lower = wrapperPath.toLowerCase(); // UTF-8 BOM: Windows PowerShell 5.1 decodes BOM-less .ps1 files in the ANSI // codepage, which mangles non-ASCII paths embedded in the shim. if (lower.endsWith(".ps1")) return `\uFEFF${buildWindowsPowerShellCodexShim(realCodexPath, bun, cli, bunRuntimeSource)}`; if (lower.endsWith(".cmd") || lower.endsWith(".bat")) return buildWindowsCodexShim(realCodexPath, bun, cli, bunRuntimeSource); // Extensionless Git-Bash sh launcher: sh shim with forward-slash paths. return buildUnixCodexShim(gitBashPath(realCodexPath), gitBashPath(bun), gitBashPath(cli), bunRuntimeSource, gitBashPath(serviceApiTokenFilePath())); } export function writeShim(wrapperPath: string, realCodexPath: string, runtime?: DurableBunRuntime): FileIdentity | undefined { const { bun, bunRuntimeSource, cli } = cliEntry(runtime); if (process.platform === "win32") { assertLegacyShimMutationAllowed(); // Never write through a link or a file another path shares: the write would land outside this wrapper. const existing = (() => { try { return lstatSync(wrapperPath, { bigint: true }); } catch { return null; } })(); if (existing && (existing.isSymbolicLink() || !existing.isFile() || existing.nlink > 1n)) { throw new Error("Codex shim wrapper path is not a private regular file; refusing to write through it"); } writeFileSync(wrapperPath, windowsShimContent(wrapperPath, realCodexPath, runtime), "utf8"); return undefined; } else { // Stage the wrapper as its own inode and rename it into place, so ownership // comes from the write itself rather than from observing the path afterwards. // Writing the destination directly leaves a window in which a concurrent // updater can replace the file between our write and our fingerprint; we would // then adopt that replacement as ours and unlink it during rollback, deleting // an executable we never wrote. // Hidden and non-executable while staged, so a crash between the write and the // rename cannot leave an executable `codex*` artifact that a glob or a shell // completion would surface. const staged = join(dirname(wrapperPath), `.${basename(wrapperPath)}.opencodex-staging.${process.pid}.${randomUUID()}`); let renamed = false; try { // "wx" fails if the staging path somehow exists, so we never inherit a file. writeFileSync(staged, buildUnixCodexShim(realCodexPath, bun, cli, bunRuntimeSource), { encoding: "utf8", flag: "wx", mode: 0o600 }); const stagedStat = lstatSync(staged, { bigint: true }); chmodSync(staged, 0o755); renameSync(staged, wrapperPath); renamed = true; // rename() preserves dev/ino and updates ctime, so identity is the inode // pair, captured from the file we created rather than from the destination. return { dev: stagedStat.dev, ino: stagedStat.ino }; } finally { if (!renamed) { try { unlinkSync(staged); } catch { /* best-effort: nothing to clean up */ } } } } } /** * The fingerprint to record as "we wrote this", or `undefined` when the file at * `wrapperPath` is not the inode `writeShim()` created. Returning `undefined` * makes every rollback path treat the file as someone else's and leave it alone. */ export function ownedWrapperFingerprint( wrapperPath: string, written: FileIdentity | undefined, ): ShimPathFingerprint | undefined { const probe = stableShimPathProbe(wrapperPath); if (!probe) return undefined; // Platforms that still write in place (Windows) have no staged identity; fall // back to the marker check they have always used. if (!written) return probe.prefix.includes(SHIM_MARKER) ? probe.fingerprint : undefined; if (!sameFileIdentity(probe.fingerprint.identity, written)) return undefined; return probe.fingerprint; } /** * Whether the file now at the wrapper path is one this transaction may unlink. * * The inode our write created is the authority. It stays ours through an in-place * truncation — a partial write we must clean up — and stops being ours the moment * someone renames a different file over the path, which is exactly the concurrent * updater we must not delete. Where no inode was recorded (Windows writes the * destination directly), fall back to the exact fingerprint recorded at the time. */ export function wrapperInodeIsOurs( wrapper: StableShimPathProbe, written: FileIdentity | undefined, recorded: ShimPathFingerprint | undefined, ): boolean { // A different inode is conclusive: someone renamed their own file over ours. if (written && !sameFileIdentity(wrapper.fingerprint.identity, written)) { return false; } // Same inode is not sufficient on its own — an in-place truncation (shell `>`, // writeFileSync) keeps it while replacing the contents. When we recorded a full // fingerprint, require it to still match; that covers our own partial write, // whose fingerprint we record before anything can fail. if (recorded !== undefined) return sameFingerprint(wrapper.fingerprint, recorded); // No recorded fingerprint: only the inode identity we captured at write time can // speak for us, and there is nothing else to distinguish this file. return written !== undefined; }