@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
206 lines (185 loc) • 8 kB
text/typescript
import { execFileSync } from "node:child_process";
import { existsSync, readdirSync, readFileSync } from "node:fs";
import {
listWindowsSnapshots,
tokenizeCommandLine,
type ProcessSnapshot,
} from "../app-server-processes";
export interface CodexWriterProcess {
pid: number;
commandLine: string;
}
export type CodexWriterProcessCheck =
| { state: "ok"; processes: CodexWriterProcess[] }
| { state: "unknown"; reason: "enumeration_failed" };
export interface CodexWriterProcessIo {
platform?: NodeJS.Platform;
getuid?: () => number | undefined;
listSnapshots?: () => ProcessSnapshot[];
}
const TARGET_TRIPLE = /^[a-z0-9_]+-[a-z0-9_]+-[a-z0-9_]+(?:-[a-z0-9_]+)?$/i;
function basename(token: string): string {
return token.replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? "";
}
function isOfficialCodexExecutable(token: string): boolean {
const base = basename(token);
if (base === "codex" || base === "codex.exe" || base === "codex.cmd") return true;
const withoutSuffix = base.replace(/\.(?:exe|cmd)$/i, "");
if (!withoutSuffix.startsWith("codex-")) return false;
return TARGET_TRIPLE.test(withoutSuffix.slice("codex-".length));
}
function isCodeModeHostExecutable(token: string): boolean {
const base = basename(token);
return base === "codex-code-mode-host" || base === "codex-code-mode-host.exe";
}
function isInterpreterExecutable(token: string): boolean {
const base = basename(token);
return base === "node" || base === "node.exe"
|| base === "bun" || base === "bun.exe"
|| base === "deno" || base === "deno.exe";
}
function looksLikePathPrefix(token: string): boolean {
return token.startsWith("/") || token.startsWith("./") || token.startsWith("../")
|| token.startsWith("~") || /^[a-z]:[\\/]/i.test(token);
}
function flattenedPathPrefix(
commandLine: string,
predicate: (candidate: string) => boolean,
): { executable: string; remainder: string } | null {
const parts = commandLine.trim().split(/\s+/).filter(Boolean);
for (let end = parts.length; end >= 1; end -= 1) {
const executable = parts.slice(0, end).join(" ");
if (!predicate(executable)) continue;
return { executable, remainder: parts.slice(end).join(" ") };
}
return null;
}
function interpreterHostWithFlattenedPath(commandLine: string, tokens: readonly string[]): boolean {
if (tokens.length < 2 || !isInterpreterExecutable(tokens[0]!)) return false;
const trimmed = commandLine.trim();
const firstWhitespace = trimmed.search(/\s/);
if (firstWhitespace < 0) return false;
const remainder = trimmed.slice(firstWhitespace).trim();
return flattenedPathPrefix(remainder, isCodeModeHostExecutable) !== null;
}
/**
* Match official Codex writer executables at argv0 plus the repository's
* established interpreter-entrypoint form for code-mode-host.
*
* OS process listings can flatten argv into a display string. When an unquoted
* executable path contains spaces, recover only a leading path-shaped executable
* prefix; arbitrary later argv tokens still never turn a process into Codex.
*/
export function isCodexWriterCommandLine(commandLine: string, executable?: string): boolean {
if (executable && (isOfficialCodexExecutable(executable) || isCodeModeHostExecutable(executable))) return true;
const tokens = tokenizeCommandLine(commandLine.trim());
if (tokens.length === 0) return false;
if (isOfficialCodexExecutable(tokens[0]!) || isCodeModeHostExecutable(tokens[0]!)) return true;
return tokens.length > 1
&& isInterpreterExecutable(tokens[0]!)
&& isCodeModeHostExecutable(tokens[1]!);
}
function statusUid(status: string): number | undefined {
const match = /^Uid:\s+(\d+)/m.exec(status);
if (!match) return undefined;
const value = Number(match[1]);
return Number.isSafeInteger(value) ? value : undefined;
}
function listLinuxSnapshots(uid: number | undefined): ProcessSnapshot[] {
if (!existsSync("/proc")) throw new Error("procfs_unavailable");
const rows: ProcessSnapshot[] = [];
for (const entry of readdirSync("/proc")) {
if (!/^\d+$/.test(entry)) continue;
const pid = Number(entry);
if (!Number.isSafeInteger(pid) || pid <= 0) continue;
try {
const procUid = statusUid(readFileSync(`/proc/${pid}/status`, "utf8"));
if (uid !== undefined && procUid !== undefined && procUid !== uid) continue;
const argv = readFileSync(`/proc/${pid}/cmdline`)
.toString("utf8")
.split("\0")
.filter(Boolean);
const commandLine = argv.join(" ").trim();
if (commandLine) rows.push({ pid, commandLine, executable: argv[0], uid: procUid });
} catch {
// A process disappearing mid-enumeration is normal. A top-level procfs
// failure is handled before the loop and fails closed.
}
}
return rows;
}
function listDarwinSnapshots(uid: number | undefined): ProcessSnapshot[] {
const commandOutput = uid !== undefined
? execFileSync("/bin/ps", ["-u", String(uid), "-o", "pid=,command="], {
encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5_000,
})
: execFileSync("/bin/ps", ["-axo", "pid=,uid=,command="], {
encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5_000,
});
const executableOutput = uid !== undefined
? execFileSync("/bin/ps", ["-u", String(uid), "-o", "pid=,comm="], {
encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5_000,
})
: execFileSync("/bin/ps", ["-axo", "pid=,comm="], {
encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5_000,
});
const executableByPid = new Map<number, string>();
for (const raw of executableOutput.split(/\r?\n/)) {
const match = /^\s*(\d+)\s+(.+)$/.exec(raw);
if (!match) continue;
const pid = Number(match[1]);
const executable = match[2]?.trim() ?? "";
if (Number.isSafeInteger(pid) && pid > 0 && executable) executableByPid.set(pid, executable);
}
const rows: ProcessSnapshot[] = [];
for (const raw of commandOutput.split(/\r?\n/)) {
const line = raw.trim();
if (!line) continue;
const match = uid !== undefined
? /^(\d+)\s+(.*)$/.exec(line)
: /^(\d+)\s+(\d+)\s+(.*)$/.exec(line);
if (!match) continue;
const pid = Number(match[1]);
const commandLine = (uid !== undefined ? match[2] : match[3])?.trim() ?? "";
if (!Number.isSafeInteger(pid) || pid <= 0 || !commandLine) continue;
rows.push({
pid, commandLine, executable: executableByPid.get(pid),
uid: uid ?? (Number.isSafeInteger(Number(match[2])) ? Number(match[2]) : undefined),
});
}
return rows;
}
function effectiveUid(getuid?: () => number | undefined): number | undefined {
try {
return getuid ? getuid() : process.getuid?.();
} catch {
return undefined;
}
}
function defaultSnapshots(platform: NodeJS.Platform, uid: number | undefined): ProcessSnapshot[] {
if (platform === "win32") return listWindowsSnapshots();
if (platform === "darwin") return listDarwinSnapshots(uid);
if (platform === "linux") return listLinuxSnapshots(uid);
throw new Error("unsupported_process_enumeration_platform");
}
export function listRunningCodexProcesses(io: CodexWriterProcessIo = {}): CodexWriterProcessCheck {
const platform = io.platform ?? process.platform;
let snapshots: ProcessSnapshot[];
try {
snapshots = io.listSnapshots?.() ?? defaultSnapshots(platform, effectiveUid(io.getuid));
} catch {
return { state: "unknown", reason: "enumeration_failed" };
}
const byPid = new Map<number, CodexWriterProcess>();
for (const snapshot of snapshots) {
if (!Number.isSafeInteger(snapshot.pid) || snapshot.pid <= 0) continue;
if (!isCodexWriterCommandLine(snapshot.commandLine, snapshot.executable)) continue;
if (!byPid.has(snapshot.pid)) {
byPid.set(snapshot.pid, { pid: snapshot.pid, commandLine: snapshot.commandLine });
}
}
return {
state: "ok",
processes: [...byPid.values()].sort((a, b) => a.pid - b.pid),
};
}