UNPKG

@bitkyc08/opencodex

Version:

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

423 lines (385 loc) • 19.7 kB
import { existsSync, lstatSync, readdirSync, readlinkSync, realpathSync, rmdirSync, unlinkSync, type Stats } from "node:fs"; import { basename, dirname, isAbsolute, join, parse, resolve, sep } from "node:path"; import { isWindowsReparsePoint, nativeReparseProbeApplies } from "./private-sqlite-path"; import { isCurrentWindowsProcessElevated } from "./windows-elevation"; import { verifyWindowsEntriesAcl, WINDOWS_OWNER_ACL_TIMEOUT_MS, type WindowsAclEntry } from "./windows-owner-acl"; /** * Path checks for `ocx uninstall`'s owned-state removal. Every recorded path is resolved from the * canonical config root one component at a time: the directories between the root and the entry must * be real directories that resolve exactly to their root-relative location, checked again immediately * before each unlink, listing and rmdir. An entry that does not meet this stays in place and is * reported. The guarantee covers the state each check observes; Bun and Node provide no * directory-handle-relative unlink, so it does not extend to a concurrent change made by the same * account between a check and the removal that follows it. */ // Read once at load: tests replace `process.platform`, and the native query must follow the real system. const NATIVE_REPARSE = nativeReparseProbeApplies(process.platform, process.arch); const DARWIN_LS_BATCH = 128; /** Linux resolves up to 40 links in one lookup (macOS 32); a longer chain or a cycle stops here. */ const MAX_LINK_DEPTH = 40; /** * Paths per ACL read. Each read is one bounded PowerShell call taking its paths over stdin, so a * large tree costs more reads rather than outgrowing a single read's deadline. */ const WINDOWS_ACL_BATCH = 256; export class OwnedPathRedirectedError extends Error { constructor() { super("a directory on the way to the owned path is not a real directory inside the config root"); this.name = "OwnedPathRedirectedError"; } } export const ELEVATED_UNINSTALL_REFUSAL = "ocx uninstall is running with elevated privileges, but another account can change " + "the config directory, a directory above it or a directory inside it, or the config directory holds a link that leads " + "outside it (on Windows, any link). Run 'ocx uninstall' as the account that owns the config directory, without sudo or administrator rights, " + "or restrict those directories to that account and remove such links first."; /** Windows without the native token probe (Bun cannot run `bun:ffi` on ARM64): the run is treated as elevated. */ export const UNKNOWN_ELEVATION_UNINSTALL_REFUSAL = "ocx uninstall could not determine whether it is running with elevated " + "privileges, and could not confirm that only this account can change the config directory. Stop opencodex, then " + "remove the config directory yourself."; let elevationProbeForTests: (() => boolean) | null = null; let directoryListedHookForTests: ((path: string) => void) | null = null; /** Test seam: decide whether uninstall counts as elevated; null restores the platform probe. */ export function setUninstallElevationProbeForTests(probe: (() => boolean) | null): void { elevationProbeForTests = probe; } /** Test seam: called after an owned directory is listed and before its children are removed. */ export function setOwnedDirectoryListedHookForTests(hook: ((path: string) => void) | null): void { directoryListedHookForTests = hook; } type Elevation = "elevated" | "unelevated" | "unknown"; /** POSIX effective uid 0, or an elevated Windows token; a Windows token the native probe cannot read is unknown. */ function uninstallElevation(): Elevation { if (elevationProbeForTests) return elevationProbeForTests() ? "elevated" : "unelevated"; if (process.platform !== "win32") return process.geteuid?.() === 0 ? "elevated" : "unelevated"; const native = isCurrentWindowsProcessElevated(); return native === null ? "unknown" : native ? "elevated" : "unelevated"; } /** Whether the ownership checks apply: an elevated run, or one whose elevation is unknown. */ export function uninstallRunsElevated(): boolean { return uninstallElevation() !== "unelevated"; } function samePath(left: string, right: string): boolean { return process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right; } /** A link of any kind: a symlink or junction, or on Windows any other reparse point. */ function isLinkEntry(path: string, entry: Stats): boolean { return entry.isSymbolicLink() || (NATIVE_REPARSE && isWindowsReparsePoint(path)); } /** Another account can change this directory's entries (POSIX mode and owner). */ function posixSharedWritable(entry: Stats, euid: number): boolean { return entry.uid !== euid || (entry.mode & 0o022) !== 0; } /** An ancestor no other account can change: owned by the uid or root, and not shared-writable unless sticky. */ function posixTrustedAncestor(entry: Stats, euid: number): boolean { const sticky = (entry.mode & 0o1000) !== 0; return (entry.uid === euid || entry.uid === 0) && ((entry.mode & 0o022) === 0 || sticky); } function errorCode(error: unknown): unknown { return error !== null && typeof error === "object" && "code" in error ? error.code : undefined; } type Walk = { path: string; complete: boolean }; /** * Every directory and link a spelling walk passed. macOS ACLs grant access independently of mode * bits, including the right to delete a link itself, so each of them is ACL-checked afterwards. */ type Visited = Set<string>; /** * Walk `parts` from the trusted directory `start` the way the kernel resolves them, following * links. Every directory passed must be a trusted ancestor and every link must be owned by the uid or * root, since a sticky directory still lets a link's owner replace it. A link target's `..` is taken * from the physical directory reached so far, as the kernel does. Stops at the first missing entry. */ function walkTrusted( start: string, parts: readonly string[], euid: number, depth: number, visited: Visited, /** The last component may be a regular file: a link in the tree can name a file. */ finalMayBeFile = false, ): Walk { let current = start; const meaningful = parts.filter(part => part !== "" && part !== "."); for (const [index, part] of meaningful.entries()) { const last = index === meaningful.length - 1; if (part === "..") { current = dirname(current); continue; } const next = join(current, part); let entry: Stats; try { entry = lstatSync(next); } catch (error) { if (errorCode(error) === "ENOENT") return { path: current, complete: false }; throw error; } if (entry.isSymbolicLink()) { if (depth >= MAX_LINK_DEPTH || (entry.uid !== euid && entry.uid !== 0)) throw new OwnedPathRedirectedError(); visited.add(next); const target = readlinkSync(next); const walked = walkTrusted( isAbsolute(target) ? parse(target).root : current, target.split(sep), euid, depth + 1, visited, finalMayBeFile && last, ); if (!walked.complete) return walked; current = walked.path; continue; } if (finalMayBeFile && last && entry.isFile()) { current = next; continue; } if (!entry.isDirectory() || !posixTrustedAncestor(entry, euid)) throw new OwnedPathRedirectedError(); visited.add(next); current = next; } return { path: current, complete: true }; } /** * The spelling uninstall was given must resolve only through directories and links no other account * can change, because the teardown steps before the remover use it as given. A root that does not * exist yet needs its nearest existing directory closed to every other account, sticky or not. * Returns what the walk passed, for the ACL check, or null when the spelling is not trusted. */ function posixSpellingVisited(configDir: string, euid: number): string[] | null { const absolute = resolve(configDir); const top = parse(absolute).root; if (!posixTrustedAncestor(lstatSync(top), euid)) return null; const visited: Visited = new Set([top]); const walked = walkTrusted(top, absolute.slice(top.length).split(sep), euid, 0, visited); // The walk built its path from verified real directories; its realpath only normalizes spelling // (case, Unicode form), which a case- or normalization-insensitive volume may store differently. if (walked.complete) return realpathSync.native(walked.path) === realpathSync.native(configDir) ? [...visited] : null; const nearest = lstatSync(walked.path); return (nearest.uid === euid || nearest.uid === 0) && (nearest.mode & 0o022) === 0 ? [...visited, walked.path] : null; } /** Windows: no component of the given spelling may be a link; returns the nearest existing directory. */ function windowsSpellingNearest(configDir: string): string | null { const absolute = resolve(configDir); let current = parse(absolute).root; for (const part of absolute.slice(current.length).split(sep).filter(Boolean)) { const next = join(current, part); let entry: Stats; try { entry = lstatSync(next); } catch (error) { if (errorCode(error) === "ENOENT") return current; throw error; } if (!entry.isDirectory() || isLinkEntry(next, entry)) return null; current = next; } return current; } /** * Throw unless the root still resolves to itself and every directory in `parts` below it is a real * directory, not a link, whose resolved path stays inside the root. The relative part is not compared * as a string: a case- or normalization-insensitive volume may store a name in another spelling. With * `elevatedUid` set, each directory below the root must also be owned by that uid and not group- or * other-writable. */ function assertRealDirectoryChain(rootPath: string, parts: readonly string[], options: OwnedRemovalOptions): void { const root = lstatSync(rootPath); if (!root.isDirectory() || root.isSymbolicLink()) throw new OwnedPathRedirectedError(); if (options.rootIdentity && !sameIdentity(rootPath, options.rootIdentity)) throw new OwnedPathRedirectedError(); if (!samePath(realpathSync.native(rootPath), rootPath)) throw new OwnedPathRedirectedError(); let current = rootPath; for (const part of parts) { current = join(current, part); const entry = lstatSync(current); if (!entry.isDirectory() || isLinkEntry(current, entry)) throw new OwnedPathRedirectedError(); if (options.elevatedUid !== undefined && posixSharedWritable(entry, options.elevatedUid)) throw new OwnedPathRedirectedError(); } if (parts.length > 0 && !isInsideRoot(rootPath, realpathSync.native(current))) throw new OwnedPathRedirectedError(); } function isInsideRoot(rootPath: string, candidate: string): boolean { const prefix = rootPath.endsWith(sep) ? rootPath : rootPath + sep; return process.platform === "win32" ? candidate.toLowerCase().startsWith(prefix.toLowerCase()) : candidate.startsWith(prefix); } function isAtOrInsideRoot(rootPath: string, candidate: string): boolean { return samePath(candidate, rootPath) || isInsideRoot(rootPath, candidate); } /** The device and inode of the directory a canonical root named when it was resolved. */ export type RootIdentity = { dev: bigint; ino: bigint }; export function rootIdentity(rootPath: string): RootIdentity { const entry = lstatSync(rootPath, { bigint: true }); return { dev: entry.dev, ino: entry.ino }; } function sameIdentity(rootPath: string, identity: RootIdentity): boolean { const entry = lstatSync(rootPath, { bigint: true }); return entry.dev === identity.dev && entry.ino === identity.ino; } /** * Whether the canonical root is still a real directory that resolves to itself and, with * `identity`, is still the directory it named when it was resolved. */ export function canonicalRootUnchanged(rootPath: string, identity?: RootIdentity): boolean { try { assertRealDirectoryChain(rootPath, [], { rootIdentity: identity }); return true; } catch { return false; } } /** * Whether the recorded entry `parts` exists below `rootPath`. Absent means a real directory on the * way, or the entry itself, does not exist (or a regular file sits where a directory would be). A link * on the way, or any other lookup failure, throws so the entry is reported rather than dropped. */ export function ownedEntryPresent(rootPath: string, parts: readonly string[]): boolean { let current = rootPath; for (const [index, part] of parts.entries()) { current = join(current, part); let entry: Stats; try { entry = lstatSync(current); } catch (error) { if (errorCode(error) === "ENOENT") return false; throw error; } if (index === parts.length - 1) return true; if (isLinkEntry(current, entry)) throw new OwnedPathRedirectedError(); if (!entry.isDirectory()) return false; } return false; } export interface OwnedRemovalOptions { /** POSIX uid of an elevated run: directories removal passes through must belong to it alone. */ elevatedUid?: number; /** The root's identity when it was resolved; every check also requires the root to still be it. */ rootIdentity?: RootIdentity; } /** * Remove the recorded entry `parts` below the canonical `rootPath`. A final-component link is * unlinked itself, never its target; a directory is emptied and removed with the chain rechecked for * every child and before the rmdir. */ export function removeOwnedEntry(rootPath: string, parts: readonly string[], options: OwnedRemovalOptions = {}): void { assertRealDirectoryChain(rootPath, parts.slice(0, -1), options); const path = join(rootPath, ...parts); const entry = lstatSync(path); if (entry.isSymbolicLink() || !entry.isDirectory()) { unlinkSync(path); return; } assertRealDirectoryChain(rootPath, parts, options); const names = readdirSync(path); directoryListedHookForTests?.(path); for (const name of names) removeOwnedEntry(rootPath, [...parts, name], options); assertRealDirectoryChain(rootPath, parts, options); rmdirSync(path); } /** * Every real directory in the root's tree, and every link in it, for the ownership checks. The * teardown steps before the remover read and write files anywhere in the tree, so a link at any * depth, to a file or a directory, must resolve to the root or a place inside it, through * directories and links `resolveLink` accepts (it returns what it passed, or null). One that does * not makes the tree unacceptable and the result is null. */ function rootTree( rootPath: string, resolveLink: (link: string) => { path: string; visited: string[] } | null, ): { directories: string[]; links: string[] } | null { const directories: string[] = []; const links: string[] = []; const pending = [rootPath]; while (pending.length > 0) { const directory = pending.pop()!; directories.push(directory); for (const name of readdirSync(directory)) { const child = join(directory, name); const entry = lstatSync(child); if (isLinkEntry(child, entry)) { const resolved = resolveLink(child); if (resolved === null || !isAtOrInsideRoot(rootPath, resolved.path)) return null; links.push(...resolved.visited); } else if (entry.isDirectory()) { pending.push(child); } } } return { directories, links }; } function rootAncestors(rootPath: string): string[] { const ancestors: string[] = []; for (let current = dirname(rootPath); ; current = dirname(current)) { ancestors.push(current); if (dirname(current) === current) return ancestors; } } function windowsAclAllows(entries: readonly WindowsAclEntry[]): boolean { for (let start = 0; start < entries.length; start += WINDOWS_ACL_BATCH) { if (!verifyWindowsEntriesAcl(entries.slice(start, start + WINDOWS_ACL_BATCH), WINDOWS_OWNER_ACL_TIMEOUT_MS)) return false; } return true; } /** * macOS extended ACLs grant access independently of the mode bits. True when no listed directory has * an allow entry; deny entries (such as the stock "everyone deny delete") take nothing away from the * owner. A failed read counts as an allow entry. */ function darwinAclsDenyOnly(paths: readonly string[]): boolean { for (let start = 0; start < paths.length; start += DARWIN_LS_BATCH) { const result = Bun.spawnSync(["/bin/ls", "-lde", "--", ...paths.slice(start, start + DARWIN_LS_BATCH)], { stdin: "ignore", stdout: "pipe", stderr: "ignore", env: { PATH: "/usr/bin:/bin", LC_ALL: "C" }, }); if (!result.success) return false; if (result.stdout.toString().split("\n").some(line => /^\s*\d+: .* allow \S+$/.test(line))) return false; } return true; } /** * When uninstall runs elevated, a reason to refuse the whole run if another account can change the * spelling it was given, the canonical root, one of its ancestors, or any directory in the root's * tree, or if a link in that tree leads outside it. Null when the run is not elevated or all of it * belongs to the elevated account alone. A missing root is checked through its nearest existing * directory. A run whose elevation is unknown is checked as elevated. */ export function elevatedRemovalRefusal(configDir: string): string | null { const elevation = uninstallElevation(); if (elevation === "unelevated") return null; const refusal = elevation === "unknown" ? UNKNOWN_ELEVATION_UNINSTALL_REFUSAL : ELEVATED_UNINSTALL_REFUSAL; try { return onlyThisAccountCanChange(configDir) ? null : refusal; } catch { return refusal; } } function onlyThisAccountCanChange(configDir: string): boolean { if (process.platform === "win32") { const nearest = windowsSpellingNearest(configDir); if (nearest === null) return false; if (!existsSync(configDir)) { return windowsAclAllows([ ...rootAncestors(nearest).map(path => ({ path, directory: true, policy: "trusted-ancestry" as const })), { path: nearest, directory: true, policy: "write-private" as const }, ]); } const rootPath = realpathSync.native(configDir); // An elevated Windows run accepts no link or reparse point anywhere in the tree. const tree = rootTree(rootPath, () => null); if (tree === null) return false; return windowsAclAllows([ ...rootAncestors(rootPath).map(path => ({ path, directory: true, policy: "trusted-ancestry" as const })), ...tree.directories.map(path => ({ path, directory: true, policy: "write-private" as const })), ]); } const euid = process.geteuid?.(); if (euid === undefined) return false; const visited = posixSpellingVisited(configDir, euid); if (visited === null) return false; const darwin = process.platform === "darwin"; if (!existsSync(configDir)) return !darwin || darwinAclsDenyOnly(visited); const rootPath = realpathSync.native(configDir); // Each link is resolved the way the kernel does, through trusted directories and links only, so a // link that leaves the root on the way back into it is refused as well. const tree = rootTree(rootPath, link => { const linkVisited: Visited = new Set(); const walked = walkTrusted(dirname(link), [basename(link)], euid, 0, linkVisited, true); return walked.complete ? { path: realpathSync.native(walked.path), visited: [...linkVisited] } : null; }); if (tree === null) return false; const ancestors = rootAncestors(rootPath); if (!ancestors.every(path => posixTrustedAncestor(lstatSync(path), euid))) return false; if (tree.directories.some(path => posixSharedWritable(lstatSync(path), euid))) return false; return !darwin || darwinAclsDenyOnly([...new Set([...visited, ...ancestors, ...tree.directories, ...tree.links])]); }