UNPKG

@bitkyc08/opencodex

Version:

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

119 lines (106 loc) • 4.97 kB
import { closeSync, constants as fsConstants, fstatSync, lstatSync, openSync, readFileSync, readSync, statSync, type BigIntStats, } from "node:fs"; import { readBoundedLocalFile } from "./orca-auth-source"; import { atomicWriteFile, type AtomicWriteHooks } from "../config/atomic-write"; export const MAX_AUTH_BYTES = 4 * 1024 * 1024; export interface BoundedReadTestSeam { beforeOpen?: (path: string) => void; afterValidatedOpen?: (path: string, fd: number) => void; onBufferAllocated?: (byteLength: number) => void; onRead?: (requestedBytes: number, bytesRead: number, totalBytesRead: number) => void; } export type NativeMainAuthReadMode = "plain" | "bounded" | "local-bounded"; /** Reads the raw bytes of a native-main login file. Throws the error of the underlying read unchanged. */ export function readNativeMainAuthBytes(path: string, mode: NativeMainAuthReadMode, limit?: number): Buffer { if (mode === "plain") return readFileSync(path); if (mode === "bounded") return readBounded(path, limit ?? MAX_AUTH_BYTES); return Buffer.from(readBoundedLocalFile(path, limit ?? MAX_AUTH_BYTES), "utf8"); } export function nativeAuthStatStamp(value: BigIntStats): string { return `${value.dev}:${value.ino}:${value.size}:${value.mtimeNs}:${value.ctimeNs}`; } /** * Plain read bracketed by a stat before and after (#7345 retention). The identity is the file's * dev/ino when both stats name the same file, and null when it was replaced during the read. The * bytes still come from the plain path read, so read-count oracles observe it. Throws the error of * either stat or the read unchanged: a file removed right after the read is missing, not a login. */ export function readNativeMainAuthBytesWithIdentity(path: string): { bytes: Buffer; identity: { dev: bigint; ino: bigint } | null } { const before = statSync(path, { bigint: true }); const bytes = readNativeMainAuthBytes(path, "plain"); const after = statSync(path, { bigint: true }); const same = after.dev === before.dev && after.ino === before.ino; return { bytes, identity: same ? { dev: after.dev, ino: after.ino } : null }; } /** Reads with a stat before and after, as the desktop identity reader did. */ export function readNativeMainAuthBytesStable(path: string, maxBytes: bigint): { bytes: Buffer; stat: BigIntStats } { const before = statSync(path, { bigint: true }); if (before.size > maxBytes) throw new Error('Unexpected native auth size'); const bytes = readFileSync(path); const after = statSync(path, { bigint: true }); if (nativeAuthStatStamp(before) !== nativeAuthStatStamp(after)) throw new Error('Native credentials changed during read'); return { bytes, stat: after }; } /** The only sync writer of a native-main login file. */ export function writeNativeMainAuthFile(path: string, content: string, hooks: AtomicWriteHooks): void { atomicWriteFile(path, content, undefined, hooks); } /** The only async writer of a native-main login file. `write` keeps the caller's injected writer (a test seam of NativeProfileManager). */ export async function writeNativeMainAuthFileAsync(path: string, content: string, write: (path: string, content: string) => Promise<void>): Promise<void> { await write(path, content); } export function readBounded(path: string, limit: number, testSeam?: BoundedReadTestSeam): Buffer { let fd: number | undefined; let failed = false; try { testSeam?.beforeOpen?.(path); const flags = process.platform === "win32" ? fsConstants.O_RDONLY : fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW | fsConstants.O_NONBLOCK; fd = openSync(path, flags); const opened = fstatSync(fd, { bigint: true }); if (!opened.isFile() || opened.size > BigInt(limit)) throw new Error("invalid bounded file"); if (process.platform === "win32") { const pathEntry = lstatSync(path, { bigint: true }); if ( !pathEntry.isFile() || pathEntry.isSymbolicLink() || pathEntry.dev !== opened.dev || pathEntry.ino !== opened.ino ) throw new Error("invalid bounded file"); } testSeam?.afterValidatedOpen?.(path, fd); const buffer = Buffer.allocUnsafe(limit + 1); testSeam?.onBufferAllocated?.(buffer.byteLength); let totalBytesRead = 0; while (totalBytesRead < buffer.byteLength) { const requestedBytes = buffer.byteLength - totalBytesRead; const bytesRead = readSync(fd, buffer, totalBytesRead, requestedBytes, totalBytesRead); totalBytesRead += bytesRead; testSeam?.onRead?.(requestedBytes, bytesRead, totalBytesRead); if (bytesRead === 0) break; } if (totalBytesRead > limit) throw new Error("invalid bounded file"); return buffer.subarray(0, totalBytesRead); } catch (error) { failed = true; throw error; } finally { if (fd !== undefined) { try { closeSync(fd); } catch (error) { if (!failed) throw error; } } } }