UNPKG

@bitkyc08/opencodex

Version:

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

196 lines (173 loc) • 8.27 kB
import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, type BigIntStats } from "node:fs"; import { homedir } from "node:os"; import { join } from "node:path"; import { claudeDesktopConfigLibraryDir, resolveConfigLibraryDir } from "./desktop-3p-paths"; export interface Desktop3pConfigLibraryOptions { env?: NodeJS.ProcessEnv; platform?: NodeJS.Platform; homeDir?: string; } /** * Resolve the config library from the same user-data root Claude Desktop uses. Keeping this in one * helper prevents the writer and dashboard status probe from agreeing on a path Desktop never reads. * * The resolution itself lives in `./desktop-3p-paths`, which ports Claude Desktop's own `GE()` * branch for branch — including the `-3p` suffix the app appends to its userData root. Dropping * that suffix points us at a directory Desktop never reads (GitHub #539). */ export function resolveDesktop3pConfigLibraryPath( options: Desktop3pConfigLibraryOptions = {}, ): string { if (options.env === undefined && options.platform === undefined && options.homeDir === undefined) { return claudeDesktopConfigLibraryDir(); } return resolveConfigLibraryDir({ env: options.env ?? process.env, platform: options.platform ?? process.platform, home: options.homeDir ?? homedir(), }); } export interface Desktop3pMetadataEntry { id: string; name: string; [key: string]: unknown; } export interface Desktop3pMetadata { appliedId?: string; entries: Desktop3pMetadataEntry[]; [key: string]: unknown; } export const DESKTOP_PICKER_ENTRY_NAME = "opencodex-picker"; export const MAX_DESKTOP_PROFILE_FILE_BYTES = 4 * 1024 * 1024; export function assertDesktopLibraryTextSize(text: string): void { if (Buffer.byteLength(text, "utf8") > MAX_DESKTOP_PROFILE_FILE_BYTES) { throw new Error("desktop_config_too_large"); } } export function serializeDesktopLibraryJson(value: unknown): string { const text = JSON.stringify(value, null, 2) + "\n"; assertDesktopLibraryTextSize(text); return text; } /** A path that no longer names the observed file was swapped; a same-path failure keeps its own errno. */ function pathStillNamesExpectedFile(path: string, expected: BigIntStats): boolean { try { const now = lstatSync(path, { bigint: true }); return now.isFile() && now.dev === expected.dev && now.ino === expected.ino && now.ctimeNs === expected.ctimeNs; } catch { return false; } } /** Read regular config files only; a path swap must not turn an observation into a FIFO wait. */ export function readDesktopLibraryBytes( path: string, maxBytes: number = MAX_DESKTOP_PROFILE_FILE_BYTES, ): Buffer { if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > MAX_DESKTOP_PROFILE_FILE_BYTES) { throw new RangeError("invalid Desktop library read limit"); } const expected = lstatSync(path, { bigint: true }); if (!expected.isFile()) throw new Error("desktop_config_not_regular"); // POSIX open of a FIFO can itself block, before fstat is possible. Windows has no POSIX // FIFO entry; retain descriptor identity validation there without unsupported open flags. const flags = constants.O_RDONLY | (process.platform === "win32" ? 0 : constants.O_NONBLOCK | constants.O_NOFOLLOW); let fd: number; try { fd = openSync(path, flags); } catch (error) { // A swap can fail at open — ELOOP on a symlink, ENXIO on a socket — before fstat can // classify it. Re-observing the path reports every swap as the documented refusal. if (pathStillNamesExpectedFile(path, expected)) throw error; throw new Error("desktop_config_not_regular"); } try { const opened = fstatSync(fd, { bigint: true }); if (!opened.isFile() || opened.dev !== expected.dev || opened.ino !== expected.ino || opened.ctimeNs !== expected.ctimeNs) throw new Error("desktop_config_not_regular"); if (opened.size > BigInt(maxBytes)) throw new Error("desktop_config_too_large"); // Allocate for the observed size plus one sentinel byte, not the full cap: callers scan many // small profiles, and the cap would zero-fill megabytes per read. A file that fills the // buffer grew after validation — keep reading within the bound so it classifies as // desktop_config_too_large rather than silently truncating. let bytes = Buffer.alloc(Number(opened.size) + 1); let length = 0; for (;;) { const count = readSync(fd, bytes, length, Math.min(64 * 1024, bytes.length - length), null); if (count === 0) break; length += count; if (length > maxBytes) throw new Error("desktop_config_too_large"); if (length === bytes.length && bytes.length <= maxBytes) { const grown = Buffer.alloc(Math.min(maxBytes + 1, bytes.length * 2)); bytes.copy(grown, 0, 0, length); bytes = grown; } } if (length > maxBytes) throw new Error("desktop_config_too_large"); if (!pathStillNamesExpectedFile(path, opened)) throw new Error("desktop_config_not_regular"); return bytes.subarray(0, length); } finally { closeSync(fd); } } /** Text decoding stays identical to node:fs readFileSync(path, "utf8"). */ export function readDesktopLibraryText(path: string): string { return readDesktopLibraryBytes(path).toString("utf8"); } /** Only an absent directory entry is optional; dangling links and failed reads still refuse. */ export function readOptionalDesktopLibraryBytes(path: string): Buffer | undefined { try { return readDesktopLibraryBytes(path); } catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined; throw error; } } /** Read optional verified metadata; a present file must contain an entries array. */ export function parseMetadata(path: string): Desktop3pMetadata { const bytes = readOptionalDesktopLibraryBytes(path); if (bytes === undefined) return { entries: [] }; const parsed = JSON.parse(bytes.toString("utf8")) as Partial<Desktop3pMetadata>; if (!Array.isArray(parsed.entries)) throw new Error("Claude Desktop 3P _meta.json has no entries array"); return { ...parsed, entries: parsed.entries }; } export const SAFE_DESKTOP_PROFILE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/; export function isRecord(value: unknown): value is Record<string, unknown> { return typeof value === "object" && value !== null && !Array.isArray(value); } export function isOwnedDesktopEntry(entry: Desktop3pMetadataEntry | undefined): boolean { return entry?.name === "opencodex" || entry?.name === "opencodex-standard" || entry?.name === DESKTOP_PICKER_ENTRY_NAME; } /** A gateway row is removable; the selected standard row must always remain. */ export function isOwnedDesktopGatewayEntry(entry: Desktop3pMetadataEntry | undefined): boolean { return entry?.name === "opencodex"; } export function profilePath(libraryPath: string, id: string): string { if (!SAFE_DESKTOP_PROFILE_ID.test(id)) throw new Error("desktop_profile_id_unsafe"); return join(libraryPath, `${id}.json`); } export const OPENCODEX_DESKTOP_PROFILE_KEYS = new Set([ "inferenceProvider", "inferenceCredentialKind", "inferenceGatewayBaseUrl", "inferenceGatewayApiKey", "modelDiscoveryEnabled", "inferenceModels", ]); export interface DesktopProfileSnapshot { /** Verified bytes of the existing profile; undefined only when the entry is absent. */ bytes?: Buffer; foreign: Record<string, unknown>; } /** Capture verified bytes for key preservation, backup and rollback; publication revalidates them. */ export function readDesktopProfileSnapshot(path: string): DesktopProfileSnapshot { const bytes = readOptionalDesktopLibraryBytes(path); if (bytes === undefined) return { foreign: {} }; const parsed = JSON.parse(bytes.toString("utf8")) as unknown; if (!isRecord(parsed)) throw new Error("Claude Desktop 3P profile is not a JSON object"); const foreign = Object.fromEntries( Object.entries(parsed).filter(([key]) => !OPENCODEX_DESKTOP_PROFILE_KEYS.has(key)), ); return { bytes, foreign }; } /** Preserve settings outside the gateway-owned keys from a verified profile. */ export function readDesktopProfileForeignKeys(path: string): Record<string, unknown> { return readDesktopProfileSnapshot(path).foreign; }