@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
260 lines (257 loc) • 16.4 kB
text/typescript
import { createHash } from "node:crypto";
import { createGunzip } from "node:zlib";
import { closeSync, constants, createReadStream, fstatSync, lstatSync, openSync } from "node:fs";
import { Readable, Transform } from "node:stream";
import { pipeline } from "node:stream/promises";
import { parseStrictSemver } from "../lib/strict-semver";
import { sameFileIdentity, statTimeMs } from "../lib/file-identity";
import type { BigIntStats } from "node:fs";
import { codexCliContentFileDigest, codexCliContentSetDigest, codexCliPlatformBacking } from "./cli-install-provenance";
import { windowsArchivePathValidator, WINDOWS_CODEX_HEADER_BYTES, WINDOWS_CODEX_NATIVE_MEMBER } from "./cli-update-windows-paths";
export const CODEX_CLI_REGISTRY = "https://registry.npmjs.org";
export interface CodexCliArtifact {
readonly name: string;
readonly installName: string;
readonly version: string;
readonly integrity: string;
readonly tarball: string;
}
export interface CodexCliArtifactSet {
readonly platform: NodeJS.Platform;
readonly arch: string;
readonly main: CodexCliArtifact;
readonly backing: CodexCliArtifact;
}
export function isSha512Integrity(token: string): boolean {
if (!/^sha512-[A-Za-z0-9+/]{86}==$/.test(token)) return false;
const digest = Buffer.from(token.slice(7), "base64");
return digest.length === 64 && "sha512-" + digest.toString("base64") === token;
}
export function officialCodexTarball(value: string): boolean {
try {
const url = new URL(value);
return url.origin === CODEX_CLI_REGISTRY && !url.username && !url.password && !url.search && !url.hash;
} catch { return false; }
}
type Metadata = Record<string, any>;
function artifact(meta: Metadata, installName: string): CodexCliArtifact {
if (typeof meta.name !== "string" || typeof meta.version !== "string" || !parseStrictSemver(meta.version)
|| typeof meta.dist?.integrity !== "string" || !isSha512Integrity(meta.dist.integrity)
|| typeof meta.dist?.tarball !== "string" || !officialCodexTarball(meta.dist.tarball)) throw new Error("artifact_metadata_unverified");
return Object.freeze({ name: meta.name, installName, version: meta.version,
integrity: meta.dist.integrity, tarball: meta.dist.tarball });
}
/** Only exact optional-package versions or the publisher's exact npm alias are modeled. */
export function backingReference(main: Metadata, installName: string): { name: string; version: string; spec: string } {
const dependency = main.optionalDependencies?.[installName];
const direct = dependency === main.version;
const alias = `npm:@openai/codex@${main.version}-${installName.slice("@openai/codex-".length)}`;
if (!direct && dependency !== alias) throw new Error("backing_reference_unverified");
const name = direct ? installName : "@openai/codex";
const version = direct ? main.version : alias.slice("npm:@openai/codex@".length);
return { name, version, spec: `${name}@${version}` };
}
/** Main-metadata guard + reference derivation shared by the sync and async set builders. */
function codexCliArtifactMain(main: Metadata, platform: NodeJS.Platform, arch: string) {
const layout = codexCliPlatformBacking(platform, arch);
if (!layout || main.name !== "@openai/codex") throw new Error("artifact_platform_unverified");
const mainArtifact = artifact(main, "@openai/codex");
const reference = backingReference(main, layout.package);
return { layout, mainArtifact, reference };
}
function codexCliArtifactFinish(mainArtifact: CodexCliArtifact,
reference: { name: string; version: string; spec: string },
layout: { package: string }, backingMeta: Metadata,
platform: NodeJS.Platform, arch: string): CodexCliArtifactSet {
const backing = artifact(backingMeta, layout.package);
if (backing.name !== reference.name || backing.version !== reference.version) throw new Error("backing_metadata_unverified");
return Object.freeze({ platform, arch, main: mainArtifact, backing });
}
export function codexCliArtifactSet(main: Metadata, query: (spec: string) => Metadata,
platform: NodeJS.Platform, arch: string): CodexCliArtifactSet {
// Main integrity is refused BEFORE the backing query is issued — the tarball query
// must never run on already-unverified metadata (integrity gate, 2 queries total).
const { layout, mainArtifact, reference } = codexCliArtifactMain(main, platform, arch);
return codexCliArtifactFinish(mainArtifact, reference, layout, query(reference.spec), platform, arch);
}
/**
* The request-path twin of {@link codexCliArtifactSet}: the backing query resolves off the
* event loop, so a waiting registry child cannot stall the proxy. The platform guard and
* main-artifact check still run before any backing query is issued.
*/
export async function codexCliArtifactSetAsync(main: Metadata, query: (spec: string) => Promise<Metadata>,
platform: NodeJS.Platform, arch: string): Promise<CodexCliArtifactSet> {
const { layout, mainArtifact, reference } = codexCliArtifactMain(main, platform, arch);
return codexCliArtifactFinish(mainArtifact, reference, layout, await query(reference.spec), platform, arch);
}
export function codexCliArtifactSetDigest(set: CodexCliArtifactSet): string {
return createHash("sha256").update(JSON.stringify([set.platform, set.arch,
...[set.main, set.backing].map(file => [file.name, file.installName, file.version, file.integrity, file.tarball])])).digest("hex");
}
export const MAX_CODEX_ARCHIVE_BYTES = 256 * 1024 * 1024;
export const MAX_CODEX_UNPACKED_BYTES = 512 * 1024 * 1024;
export const MAX_CODEX_MEMBER_BYTES = 384 * 1024 * 1024;
export interface CodexArchiveFile { readonly size: number; readonly mode: number; readonly digest: string; readonly bytes: Buffer | null;
/** Optional bounded prefix from the same integrity-verified member stream, never a second path read. */
readonly nativePrefix?: Buffer }
export type CodexArchiveFiles = Map<string, CodexArchiveFile>;
/** Stream gzip and tar. Only package.json (256 KiB) and the JS entrypoint (1 MiB)
* are retained; native binaries and other files contribute a streaming digest.
* Windows x64 opt-in additionally retains at most 4 KiB of its native member.
* Official 0.163.0 linux-x64: 162,055,867 compressed, 429,938,138 unpacked,
* largest member 296,865,480 bytes. Limits are independent, not a heap budget.
*/
export async function verifyCodexCliArchive(source: Buffer | string, target: CodexCliArtifact,
options: { windowsX64?: boolean } = {}): Promise<CodexArchiveFiles> {
if (!isSha512Integrity(target.integrity)) throw new Error("artifact_integrity_mismatch");
let fd: number | undefined;
let before: BigIntStats | undefined;
if (typeof source === "string") {
fd = openSync(source, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
try { before = fstatSync(fd, { bigint: true }); } catch (error) { closeSync(fd); throw error; }
if (!before.isFile() || before.size > MAX_CODEX_ARCHIVE_BYTES) { closeSync(fd); throw new Error("artifact_file_unverified"); }
}
let input: Readable;
try {
input = typeof source === "string" ? createReadStream(source, { fd, autoClose: false, emitClose: true, highWaterMark: 64 * 1024 }) : Readable.from([source]);
} catch (error) { if (fd !== undefined) closeSync(fd); throw error; }
// The stream exclusively owns fd after construction. In Bun destroy closes
// even with autoClose:false; that option keeps the fd held through our final
// identity check, not through an explicit destroy. Never close the raw fd too.
let inputError: Error | undefined;
input.on("error", error => { inputError = error; });
const inputClosed = new Promise<void>(resolve => input.once("close", resolve));
const archiveHash = createHash("sha512");
let compressed = 0, unpacked = 0, count = 0, headerSize = 0, padding = 0, trailer = 0;
let ended = false;
const header = Buffer.alloc(512);
const files: CodexArchiveFiles = new Map();
const names = new Set<string>();
const windowsName = options.windowsX64 ? windowsArchivePathValidator() : undefined;
let current: { name: string; size: number; mode: number; remaining: number; keep: boolean;
chunks: Buffer[]; prefix?: Buffer; hash: ReturnType<typeof createHash> } | undefined;
let tracker: Transform | undefined, gunzip: ReturnType<typeof createGunzip> | undefined, pumping: Promise<void> | undefined;
let verified = false;
try {
tracker = new Transform({ transform(chunk: Buffer, _encoding, callback) {
compressed += chunk.length;
if (compressed > MAX_CODEX_ARCHIVE_BYTES) return callback(new Error("artifact_compressed_limit"));
archiveHash.update(chunk); callback(null, chunk);
} });
gunzip = createGunzip({ chunkSize: 64 * 1024 });
pumping = pipeline(input, tracker, gunzip);
void pumping.catch(() => {});
for await (const data of gunzip) {
const chunk = Buffer.from(data);
unpacked += chunk.length;
if (unpacked > MAX_CODEX_UNPACKED_BYTES) throw new Error("artifact_unpacked_limit");
let position = 0;
while (position < chunk.length) {
if (ended) {
const tail = chunk.subarray(position);
if (!tail.every(byte => byte === 0)) throw new Error("artifact_tar_trailing_data");
trailer += tail.length; break;
}
if (padding) { const take = Math.min(padding, chunk.length - position); padding -= take; position += take; continue; }
if (current) {
const take = Math.min(current.remaining, chunk.length - position);
const bytes = chunk.subarray(position, position + take);
current.hash.update(bytes);
if (current.keep) current.chunks.push(Buffer.from(bytes));
const offset = current.size - current.remaining;
if (current.prefix && offset < current.prefix.length) bytes.copy(current.prefix, offset, 0, current.prefix.length - offset);
current.remaining -= take; position += take;
if (!current.remaining) {
files.set(current.name, { size: current.size, mode: current.mode, digest: current.hash.digest("hex"),
bytes: current.keep ? Buffer.concat(current.chunks) : null,
...(current.prefix ? { nativePrefix: current.prefix } : {}) });
padding = (512 - current.size % 512) % 512; current = undefined;
}
continue;
}
const take = Math.min(512 - headerSize, chunk.length - position);
chunk.copy(header, headerSize, position, position + take); position += take; headerSize += take;
if (headerSize < 512) continue;
headerSize = 0;
if (header.every(byte => byte === 0)) { ended = true; continue; }
const field = (start: number, length: number) => header.subarray(start, start + length).toString("utf8").replace(/\0.*$/s, "");
const octal = (start: number, length: number) => {
const value = field(start, length).trim();
if (!/^[0-7]+$/.test(value)) throw new Error("artifact_tar_invalid");
return parseInt(value, 8);
};
const sum = header.reduce((total, byte, index) => total + (index >= 148 && index < 156 ? 32 : byte), 0);
if (sum !== octal(148, 8)) throw new Error("artifact_tar_invalid");
const prefix = field(345, 155);
const name = (prefix ? prefix + "/" : "") + field(0, 100);
const type = field(156, 1), size = octal(124, 12), mode = octal(100, 8);
if (++count > 4096 || !name.startsWith("package/") || /[\\\x00-\x1f]/.test(name)
|| name.replace(/\/$/, "").split("/").some(part => !part || part === ".." || part === ".") || names.has(name)
|| !["", "0", "5"].includes(type) || (type === "5" && size !== 0)
|| (type !== "5" && name.endsWith("/")) || size > MAX_CODEX_MEMBER_BYTES) throw new Error("artifact_tar_invalid");
names.add(name);
windowsName?.(name, type === "5");
if (type === "5") continue;
const relative = name.slice(8);
const keep = relative === "package.json" || relative === "bin/codex.js";
if (keep && size > (relative === "package.json" ? 256 * 1024 : 1024 * 1024)) throw new Error("artifact_metadata_limit");
current = { name: relative, size, mode, remaining: size, keep, chunks: [],
...(options.windowsX64 && relative === WINDOWS_CODEX_NATIVE_MEMBER
? { prefix: Buffer.alloc(Math.min(size, WINDOWS_CODEX_HEADER_BYTES)) } : {}),
hash: createHash("sha256").update("codex-cli-observed-file-v1\0") };
if (!size) {
files.set(relative, { size, mode, digest: current.hash.digest("hex"), bytes: keep ? Buffer.alloc(0) : null }); current = undefined;
}
}
}
await pumping;
if (!ended || trailer < 512 || current || padding || headerSize) throw new Error("artifact_tar_truncated");
if ("sha512-" + archiveHash.digest("base64") !== target.integrity) throw new Error("artifact_integrity_mismatch");
if (fd !== undefined && before && typeof source === "string") {
const after = fstatSync(fd, { bigint: true }), lexical = lstatSync(source, { bigint: true });
if (!sameFileIdentity(before, after) || before.size !== after.size
|| statTimeMs(before.mtimeNs) !== statTimeMs(after.mtimeNs) || statTimeMs(before.ctimeNs) !== statTimeMs(after.ctimeNs) || lexical.isSymbolicLink()
|| !sameFileIdentity(lexical, before)) throw new Error("artifact_file_changed");
}
verified = true;
} finally {
input.destroy(); tracker?.destroy(); gunzip?.destroy();
await pumping?.catch(() => {});
// Reawaiting the pipeline alone does not wait for ReadStream's async close.
await inputClosed;
if (verified && inputError) throw new Error("artifact_close_unverified");
}
const manifestBytes = files.get("package.json")?.bytes;
if (!manifestBytes || manifestBytes.length > 256 * 1024 || files.has("npm-shrinkwrap.json") || files.has("package-lock.json")) throw new Error("artifact_manifest_unverified");
const manifest = JSON.parse(manifestBytes.toString("utf8"));
if (manifest.name !== target.name || manifest.version !== target.version) throw new Error("artifact_manifest_unverified");
for (const key of ["dependencies", "peerDependencies", "bundledDependencies", "bundleDependencies"]) {
if (manifest[key] && Object.keys(manifest[key]).length) throw new Error("artifact_dependency_unverified");
}
return files;
}
export function verifiedCodexCliContent(set: CodexCliArtifactSet, main: CodexArchiveFiles, backing: CodexArchiveFiles): string {
const layout = codexCliPlatformBacking(set.platform, set.arch);
if (!layout) throw new Error("artifact_platform_unverified");
const manifest = JSON.parse(main.get("package.json")!.bytes!.toString("utf8"));
const ref = backingReference(manifest, layout.package);
for (const name of Object.keys(manifest.optionalDependencies ?? {})) {
if (!/^@openai\/codex-(linux|darwin|win32)-(x64|arm64)$/.test(name)) throw new Error("artifact_dependency_unverified");
backingReference(manifest, name);
}
if (ref.name !== set.backing.name || ref.version !== set.backing.version
|| (typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.codex)?.replace(/^\.\//, "") !== "bin/codex.js") throw new Error("artifact_backing_unverified");
const files = [
{ role: "manifest" as const, file: main.get("package.json") },
{ role: "entrypoint" as const, file: main.get("bin/codex.js") },
{ role: "backing-manifest" as const, file: backing.get("package.json") },
{ role: "backing-binary" as const, file: backing.get(`vendor/${layout.triple}/bin/codex`) },
];
const backingManifest = JSON.parse(backing.get("package.json")!.bytes!.toString("utf8"));
if (backingManifest.exports || backingManifest.bin || Object.keys(backingManifest.optionalDependencies ?? {}).length
|| files.some(file => !file.file) || !(main.get("bin/codex.js")!.mode & 0o111)
|| !(backing.get(`vendor/${layout.triple}/bin/codex`)!.mode & 0o111)) throw new Error("artifact_backing_unverified");
return codexCliContentSetDigest(set.platform, set.arch, layout.triple, "optional-package",
files.map(file => ({ role: file.role, digest: file.role === "manifest" || file.role === "backing-manifest"
? codexCliContentFileDigest(file.role, file.file!.bytes!) : file.file!.digest })));
}