UNPKG

@bitkyc08/opencodex

Version:

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

592 lines (544 loc) • 23.2 kB
import { existsSync, readFileSync, realpathSync, statSync } from "node:fs"; import { basename, dirname, isAbsolute, join, relative, resolve, win32 } from "node:path"; import { pnpmInvocationForPath } from "./pnpm-invocation.mjs"; import { verifyPnpmInstallTree } from "./transactional-install.mjs"; export const PNPM_BUILD_APPROVAL = "--allow-build=bun"; function outputText(value) { if (typeof value === "string") return value; if (value instanceof Uint8Array) return new TextDecoder().decode(value); return ""; } function pathKey(value, platform = process.platform) { const raw = String(value).replaceAll("\\", "/"); const normalise = path => { const result = path.replaceAll("\\", "/"); return platform === "win32" ? result.toLowerCase() : result; }; try { return normalise(realpathSync.native(raw)); } catch { return normalise(resolve(raw)); } } function lexicalPathKey(value, platform = process.platform) { const result = resolve(String(value).replaceAll("\\", "/")).replaceAll("\\", "/"); return platform === "win32" ? result.toLowerCase() : result; } function samePath(left, right, platform = process.platform) { return pathKey(left, platform) === pathKey(right, platform) || lexicalPathKey(left, platform) === lexicalPathKey(right, platform); } function singleAbsoluteCommandPath(runPnpm, commandPath, args, platform = process.platform) { let result; try { result = runPnpm(commandPath, args, true); } catch { return null; } if (result?.status !== 0) return null; const lines = outputText(result.stdout).split(/\r?\n/).map(line => line.trim()).filter(Boolean); if (lines.length !== 1 || /^(?:undefined|null)$/i.test(lines[0])) return null; return isAbsolutePath(lines[0], platform) ? lines[0] : null; } function configPathValue(runPnpm, commandPath, key, platform = process.platform) { return singleAbsoluteCommandPath(runPnpm, commandPath, ["config", "get", key], platform); } function absoluteConfigPath(value, platform = process.platform) { return typeof value === "string" && isAbsolutePath(value, platform) ? value : null; } function isAbsolutePath(value, platform = process.platform) { if (typeof value !== "string") return false; return isAbsolute(value) || ( platform === "win32" && /^(?:[A-Za-z]:[\\/]|\\\\|\/)/.test(String(value)) ); } function pathDirname(value, platform = process.platform) { return platform === "win32" ? win32.dirname(String(value)) : dirname(value); } function pathBasename(value, platform = process.platform) { return platform === "win32" ? win32.basename(String(value)) : basename(value); } /** Normalize pnpm list/root output to the versioned global group, not its node_modules root. */ function normaliseGlobalRoot(value, platform = process.platform) { if (!isAbsolutePath(value, platform)) return null; const trimmed = String(value).replace(/[\\/]+$/, ""); return pathBasename(trimmed, platform).toLowerCase() === "node_modules" ? pathDirname(trimmed, platform) : trimmed; } /** pnpm's --global-dir is the base; pnpm appends the major-version group below it. */ function globalDirFromRoot(globalRoot, platform = process.platform) { const separator = platform === "win32" ? /[\\/]/ : /\//; const match = String(globalRoot).match(new RegExp(`^(.*)${separator.source}(?:v)?\\d+$`, "i")); return match?.[1] || globalRoot; } function globalRootMatchesDir(globalRoot, globalDir, platform = process.platform) { return samePath(globalRoot, globalDir, platform) || samePath(pathDirname(globalRoot, platform), globalDir, platform); } /** Resolve manager-owned global paths, including pnpm defaults that config get leaves undefined. */ function resolveGlobalPaths(commandPath, runPnpm, listedRoot, platform = process.platform) { const listedGlobalRoot = normaliseGlobalRoot(listedRoot, platform); const commandGlobalRoot = normaliseGlobalRoot( singleAbsoluteCommandPath(runPnpm, commandPath, ["root", "-g"], platform), platform, ); if (listedGlobalRoot && commandGlobalRoot && !samePath(listedGlobalRoot, commandGlobalRoot, platform)) { return null; } const globalRoot = commandGlobalRoot ?? listedGlobalRoot; if (!globalRoot) return null; const configuredGlobalDir = absoluteConfigPath(configPathValue(runPnpm, commandPath, "global-dir", platform), platform); const globalDir = configuredGlobalDir ?? globalDirFromRoot(globalRoot, platform); const configuredGlobalBinDir = absoluteConfigPath(configPathValue(runPnpm, commandPath, "global-bin-dir", platform), platform); const globalBinDir = configuredGlobalBinDir ?? absoluteConfigPath(singleAbsoluteCommandPath(runPnpm, commandPath, ["bin", "-g"], platform), platform); if (!globalDir || !globalBinDir || !globalRootMatchesDir(globalRoot, globalDir, platform)) return null; return { globalDir, globalRoot, globalBinDir }; } function packageEntryFromRoot(root, packageName) { const maps = [root?.dependencies, root?.devDependencies, root?.optionalDependencies]; for (const dependencies of maps) { if (!dependencies || typeof dependencies !== "object") continue; const direct = dependencies[packageName]; if (direct && typeof direct === "object") return direct; } return null; } function inspectListOutput(stdout, packageName) { let roots; try { roots = JSON.parse(outputText(stdout)); } catch { return null; } if (!Array.isArray(roots)) return null; for (const root of roots) { const entry = packageEntryFromRoot(root, packageName); if (entry) return { root, entry }; } return null; } function ownerGlobalArgs(args, owner) { const input = [...args]; if (!owner) return input; const command = input[0]; if (!["add", "install", "update", "list", "remove", "uninstall"].includes(command)) return input; const rest = []; for (let index = 1; index < input.length; index += 1) { const arg = input[index]; // The owner is authoritative. Remove an accidentally inherited/supplied value rather // than relying on duplicate pnpm flags having stable precedence across pnpm 10/11. if (arg === "--global-dir" || arg.startsWith("--global-dir=")) { if (arg === "--global-dir") index += 1; continue; } if (arg === "--config.global-bin-dir" || arg.startsWith("--config.global-bin-dir=")) { if (arg === "--config.global-bin-dir") index += 1; continue; } rest.push(arg); } return [ command, `--global-dir=${owner.globalDir}`, `--config.global-bin-dir=${owner.globalBinDir}`, ...rest, ]; } /** Add the selected pnpm global group and bin directory to a command's config. */ export function pnpmGlobalCommandArgs(args, owner) { return ownerGlobalArgs(args, owner); } /** * Add the owning global bin directory to PATH for commands such as pnpm's bin * validation. Do not replace PATH: registry auth and the selected pnpm executable * can depend on the rest of the inherited environment. */ export function pnpmOwnerEnvironment(owner, env = process.env, platform = process.platform) { const key = platform === "win32" && env.Path !== undefined && env.PATH === undefined ? "Path" : "PATH"; const delimiter = platform === "win32" ? ";" : ":"; const existing = env[key] ?? env.PATH ?? env.Path ?? ""; const entries = String(existing).split(delimiter).filter(Boolean); if (!entries.some(entry => samePath(entry, owner.globalBinDir, platform))) entries.unshift(owner.globalBinDir); return { ...env, [key]: entries.join(delimiter) }; } /** Build an invocation for the already-selected pnpm executable and global group. */ export function pnpmOwnerInvocation(owner, args, platform = process.platform, env = process.env) { const ownerEnv = pnpmOwnerEnvironment(owner, env, platform); const invocation = pnpmInvocationForPath( owner.commandPath, ownerGlobalArgs(args, owner), platform, ownerEnv, ); return invocation ? { ...invocation, env: ownerEnv } : null; } function shimNames(platform) { return platform === "win32" ? ["ocx.cmd", "ocx.ps1", "opencodex.cmd", "opencodex.ps1"] : ["ocx", "opencodex"]; } function targetVariants(packageDir, globalBinDir, platform) { const packageCandidates = [packageDir]; try { packageCandidates.push(realpathSync(packageDir)); } catch { /* keep lexical path */ } const binCandidates = [globalBinDir]; try { binCandidates.push(realpathSync(globalBinDir)); } catch { /* keep lexical path */ } const launcherCandidates = packageCandidates.map(candidate => join(candidate, "bin", "ocx.mjs")); const relativeCandidates = binCandidates.flatMap(bin => launcherCandidates.map(candidate => relative(bin, candidate))); return [...new Set([...launcherCandidates, ...relativeCandidates].map(value => { const normalised = String(value).replaceAll("\\", "/").replace(/^\.\//, ""); return platform === "win32" ? normalised.toLowerCase() : normalised; }))].filter(Boolean); } function shimPointsToPackage(shimPath, packageDir, globalBinDir, platform) { try { if (samePath(shimPath, join(packageDir, "bin", "ocx.mjs"), platform)) return true; } catch { /* fall through to text inspection */ } let text; try { text = readFileSync(shimPath, "utf8").replaceAll("\\", "/"); if (platform === "win32") text = text.toLowerCase(); } catch { return false; } // A comment containing the new path is not a launcher. Generated cmd/PowerShell // shims are simple enough that the target appears on an executable line; discard // shebang/hash and REM lines before matching so a stale or hand-edited shim cannot // pass verification by mentioning the right package in a comment. const executableText = text.split(/\r?\n/).filter(line => { const trimmed = line.trim(); return !trimmed.startsWith("#") && !/^rem(?:\s|$)/i.test(trimmed); }).join("\n"); const expectedLauncher = join(packageDir, "bin", "ocx.mjs"); if (shimTargetPaths(shimPath, executableText, platform).some(target => samePath(target, expectedLauncher, platform))) { return true; } return targetVariants(packageDir, globalBinDir, platform).some(target => executableText.includes(target)); } function shimIsRunnable(shimPath, platform) { if (platform === "win32") return true; try { return (statSync(shimPath).mode & 0o111) !== 0; } catch { return false; } } function shimTargetPaths(shimPath, text, platform) { const targets = []; const launcherPattern = /((?:\$basedir(?:_win)?|\$PSScriptRoot|%~dp0|[A-Za-z]:[\\/]|\/|\.\.?[\\/])[^"'`\r\n]*[\\/]bin[\\/]ocx\.mjs)/gi; const shimDir = pathDirname(shimPath, platform); for (const match of text.matchAll(launcherPattern)) { let target = match[1]; target = target.replace(/\$basedir_win|\$basedir|\$PSScriptRoot|%~dp0/gi, shimDir); target = target.replaceAll("\\", "/"); targets.push(isAbsolutePath(target, platform) ? target : platform === "win32" ? win32.resolve(shimDir, target) : resolve(shimDir, target)); } return targets; } /** * Verify both generated command names and all launcher forms pnpm supports for * the current platform. A package list/tree check is not enough: a stale shim * can still execute the old global group after pnpm changes the active link. */ export function verifyPnpmGlobalShims( packageDir, globalBinDir, platform = process.platform, exists = existsSync, ) { if (!isAbsolutePath(globalBinDir, platform)) { return { ok: false, reason: "pnpm global bin directory is not absolute" }; } const missing = []; for (const name of shimNames(platform)) { const path = join(globalBinDir, name); if ( !exists(path) || !shimIsRunnable(path, platform) || !shimPointsToPackage(path, packageDir, globalBinDir, platform) ) missing.push(name); } return missing.length === 0 ? { ok: true } : { ok: false, reason: `pnpm generated shim verification failed (${missing.join(", ")})` }; } /** * Read and verify the package manager's active global link. `owner` constraints * make the listing a proof of the group selected during preflight, not merely a * successful listing from whichever pnpm happens to be first on PATH. */ export function readPnpmGlobalPackage( packageName, runPnpm, verify = verifyPnpmInstallTree, constraints = {}, ) { const platform = constraints.platform ?? process.platform; const expectedGlobalDir = constraints.expectedGlobalDir ?? constraints.owner?.globalDir; const expectedGlobalRoot = constraints.expectedGlobalRoot ?? constraints.owner?.globalRoot; const globalBinDir = constraints.globalBinDir ?? constraints.owner?.globalBinDir; let result; try { result = runPnpm(ownerGlobalArgs(["list", "-g", "--depth=0", "--json", packageName], constraints.owner), true); } catch { return { ok: false, reason: "pnpm global package listing failed" }; } if (result?.status !== 0) return { ok: false, reason: "pnpm global package listing failed" }; const inspected = inspectListOutput(result.stdout, packageName); const entry = inspected?.entry; const version = typeof entry?.version === "string" ? entry.version.trim() : ""; const packagePath = typeof entry?.path === "string" ? entry.path : ""; if (!version || !packagePath || !isAbsolutePath(packagePath, platform)) { return { ok: false, reason: "pnpm did not report a valid active global package" }; } if (constraints.expectedPackagePath && !samePath(packagePath, constraints.expectedPackagePath, platform)) { return { ok: false, reason: "pnpm active package is not the running package" }; } const rootPath = normaliseGlobalRoot(inspected?.root?.path, platform); if (expectedGlobalRoot || expectedGlobalDir) { // pnpm versions have reported either the global group or its node_modules root; // accept both, but require the root when the caller is proving ownership. Without // it a successful package listing cannot distinguish a command that ignored the // pinned group from the selected group. if (!rootPath) return { ok: false, reason: "pnpm did not report the selected global group" }; const rootMatches = expectedGlobalRoot ? samePath(rootPath, expectedGlobalRoot, platform) : globalRootMatchesDir(rootPath, expectedGlobalDir, platform); if (!rootMatches) return { ok: false, reason: "pnpm listed a different global group" }; } let tree; try { tree = verify(packagePath, version); } catch { return { ok: false, reason: "the active pnpm package could not be verified" }; } if (!tree?.ok) return { ok: false, reason: "the active pnpm package failed verification" }; // A valid package tree/group is enough to bind the owner before an update. The // existing shim may be stale from an older pnpm run; post-update and rollback // reads leave this enabled so a successful transaction must produce fresh shims. if (globalBinDir && constraints.checkShims !== false) { const shims = (constraints.verifyShims ?? verifyPnpmGlobalShims)( packagePath, globalBinDir, platform, ); if (!shims?.ok) return { ok: false, reason: shims?.reason ?? "pnpm global shims failed verification" }; } return { ok: true, version, path: packagePath, globalDir: expectedGlobalDir, globalRoot: rootPath || expectedGlobalRoot, globalBinDir, }; } function statusText(status) { return status === null || status === undefined ? "?" : String(status); } function packageSpec(packageName, versionOrTag) { return `${packageName}@${versionOrTag}`; } function listGlobalPackage(commandPath, packageName, runPnpm) { try { return runPnpm(commandPath, ["list", "-g", "--depth=0", "--json", packageName], true); } catch { return null; } } /** * Find the pnpm executable and global group that own the running package. Every * candidate is inspected independently; this matters when two pnpm homes expose * the same pnpm version but only one owns the current package/shim. */ export function resolvePnpmGlobalOwner({ packageName, packagePath, commandPaths, runningShimPath, runPnpm, verify = verifyPnpmInstallTree, platform = process.platform, }) { if (!isAbsolutePath(packagePath, platform)) return { ok: false, reason: "running pnpm package path is not absolute" }; let lastReason = "no pnpm global installation owns the running package"; for (const commandPath of commandPaths ?? []) { const list = listGlobalPackage(commandPath, packageName, runPnpm); if (list?.status !== 0) continue; const inspected = inspectListOutput(list.stdout, packageName); const listedPath = typeof inspected?.entry?.path === "string" ? inspected.entry.path : ""; if (!listedPath || !isAbsolutePath(listedPath, platform) || !samePath(listedPath, packagePath, platform)) continue; const paths = resolveGlobalPaths(commandPath, runPnpm, inspected?.root?.path, platform); if (!paths) { lastReason = "pnpm owns the running package but did not report its global group and bin directory"; continue; } const { globalDir, globalRoot, globalBinDir } = paths; // If the process was entered through a generated command shim, its directory is // another owner fact. This disambiguates two pnpm homes that expose the same pnpm // version and (for example after a copied prefix) report the same package path. // Direct `node bin/ocx.mjs` and Windows shims that invoke the package path do not // provide a usable shim path, so they continue to rely on the package/group proof. if (runningShimPath) { const shimName = String(runningShimPath).replaceAll("\\", "/").split("/").at(-1)?.toLowerCase(); const isCommandShim = ["ocx", "opencodex", "ocx.cmd", "opencodex.cmd", "ocx.ps1", "opencodex.ps1"].includes(shimName ?? ""); if (isCommandShim && !samePath(dirname(runningShimPath), globalBinDir, platform)) { lastReason = "pnpm package owner did not match the running global shim"; continue; } } const owner = { commandPath, packagePath: listedPath, globalDir, globalRoot, globalBinDir }; const active = readPnpmGlobalPackage( packageName, (args, capture = false) => runPnpm(commandPath, args, capture), verify, { owner, expectedPackagePath: packagePath, expectedGlobalDir: globalDir, expectedGlobalRoot: globalRoot, globalBinDir, // Owner binding must remain possible when an older pnpm invocation left // the top-level shim stale; the transaction verifies it after mutation. checkShims: false, platform, }, ); if (active.ok) return { ok: true, owner: { ...owner, packagePath: active.path, version: active.version } }; lastReason = active.reason; } return { ok: false, reason: lastReason }; } /** * Update a pnpm global package through pnpm itself. Never rename or remove files in * the pnpm store. Every command is pinned to the owner discovered before the proxy * is stopped. The pre-update proof accepts an existing stale shim; success and * rollback require a valid tree plus fresh generated shims. */ export function runPnpmGlobalUpdate({ packageName, currentVersion, targetVersion, tag, owner, runningPackagePath, runPnpm, verify = verifyPnpmInstallTree, verifyShims = verifyPnpmGlobalShims, platform = process.platform, log = () => {}, }) { if ( !owner?.commandPath || !owner?.globalDir || !owner?.globalRoot || !owner?.globalBinDir || !isAbsolutePath(owner.commandPath, platform) || !isAbsolutePath(owner.globalDir, platform) || !isAbsolutePath(owner.globalBinDir, platform) ) { return { ok: false, phase: "preflight", error: "pnpm global owner was not pinned" }; } const constraints = { owner, expectedPackagePath: runningPackagePath ?? owner.packagePath, expectedGlobalDir: owner.globalDir, expectedGlobalRoot: owner.globalRoot, globalBinDir: owner.globalBinDir, verifyShims, platform, }; const before = readPnpmGlobalPackage( packageName, runPnpm, verify, { ...constraints, checkShims: false }, ); if (!before.ok) return { ok: false, phase: "preflight", error: before.reason }; if (currentVersion && before.version !== currentVersion) { return { ok: false, phase: "preflight", error: "pnpm's active package does not match the running package" }; } const requested = targetVersion || tag; const spec = packageSpec(packageName, requested); log(`Updating ${spec} with pnpm…`); let install; try { install = runPnpm(ownerGlobalArgs(["add", "-g", PNPM_BUILD_APPROVAL, spec], owner), false); } catch { install = { status: 1 }; } // The package path may switch to a different group link, so only constrain // the group/bin pair after the command; the active package path is intentionally open. const after = readPnpmGlobalPackage( packageName, runPnpm, verify, { ...constraints, expectedPackagePath: undefined }, ); const targetMatches = after.ok && (!targetVersion || after.version === targetVersion); if (install?.status === 0 && targetMatches) { return { ok: true, phase: "done", version: after.version, path: after.path, globalDir: owner.globalDir, globalBinDir: owner.globalBinDir, }; } const installReason = install?.status !== 0 ? `pnpm update failed (${statusText(install?.status)})` : after.ok ? "pnpm update produced an unexpected active package version" : "pnpm update completed but the active package failed verification"; // A failed command may have left the original active group intact. Do not create a // second update transaction in that case; the verified previous package is already safe. if (after.ok && after.version === before.version) { return { ok: false, phase: "install", rolledBack: true, activePath: after.path, globalDir: owner.globalDir, globalBinDir: owner.globalBinDir, error: `${installReason}; previous version remains active`, }; } log(`Restoring ${packageName}@${before.version} with pnpm…`); let rollback; try { rollback = runPnpm(ownerGlobalArgs(["add", "-g", PNPM_BUILD_APPROVAL, packageSpec(packageName, before.version)], owner), false); } catch { rollback = { status: 1 }; } const restored = readPnpmGlobalPackage( packageName, runPnpm, verify, { ...constraints, expectedPackagePath: undefined }, ); if (rollback?.status === 0 && restored.ok && restored.version === before.version) { return { ok: false, phase: "rollback", rolledBack: true, activePath: restored.path, globalDir: owner.globalDir, globalBinDir: owner.globalBinDir, error: `${installReason}; previous version restored`, }; } return { ok: false, phase: "rollback", rolledBack: false, ...(restored.ok ? { activePath: restored.path } : {}), globalDir: owner.globalDir, globalBinDir: owner.globalBinDir, error: `${installReason}; previous version could not be verified after rollback`, }; }