import { spawn } from "node:child_process"; import { statSync } from "node:fs"; import path from "node:path"; import readline from "node:readline"; import { createRequire } from "node:module"; import type { CodexConfigObject, CodexConfigValue } from "./codexOptions"; import { SandboxMode, ModelReasoningEffort, ApprovalMode, WebSearchMode } from "./threadOptions"; import type { CyberAccessProgram } from "./turnOptions"; export type CodexExecArgs = { input: string; baseUrl?: string; apiKey?: string; threadId?: string | null; // --thread-source; only applies when creating a new thread threadSource?: string; images?: string[]; // --model model?: string; // --sandbox sandboxMode?: SandboxMode; // --cd workingDirectory?: string; // --add-dir additionalDirectories?: string[]; // --skip-git-repo-check skipGitRepoCheck?: boolean; // --output-schema outputSchemaFile?: string; // --cyber-access-program cyberAccessProgram?: CyberAccessProgram; // --config model_reasoning_effort modelReasoningEffort?: ModelReasoningEffort; // AbortSignal to cancel the execution signal?: AbortSignal; // --config sandbox_workspace_write.network_access networkAccessEnabled?: boolean; // --config web_search webSearchMode?: WebSearchMode; // legacy --config features.web_search_request webSearchEnabled?: boolean; // --config approval_policy approvalPolicy?: ApprovalMode; }; const INTERNAL_ORIGINATOR_ENV = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE"; const TYPESCRIPT_SDK_ORIGINATOR = "codex_sdk_ts"; const CODEX_NPM_NAME = "@openai/codex"; const PLATFORM_PACKAGE_BY_TARGET: Record = { "x86_64-unknown-linux-musl": "@openai/codex-linux-x64", "aarch64-unknown-linux-musl": "@openai/codex-linux-arm64", "x86_64-apple-darwin": "@openai/codex-darwin-x64", "aarch64-apple-darwin": "@openai/codex-darwin-arm64", "x86_64-pc-windows-msvc": "@openai/codex-win32-x64", "aarch64-pc-windows-msvc": "@openai/codex-win32-arm64", }; const moduleRequire = createRequire(import.meta.url); type CodexPathResolution = { executablePath: string; pathDirs: string[]; }; export class CodexExec { private executablePath: string; private pathDirs: string[]; private envOverride?: Record; private configOverrides?: CodexConfigObject; private rawConfigOverrides?: string[]; constructor( executablePath: string | null = null, env?: Record, configOverrides?: CodexConfigObject, rawConfigOverrides?: string[], ) { if (executablePath) { this.executablePath = executablePath; this.pathDirs = []; } else { const resolved = findCodexPath(); this.executablePath = resolved.executablePath; this.pathDirs = resolved.pathDirs; } this.envOverride = env; this.configOverrides = configOverrides; this.rawConfigOverrides = rawConfigOverrides; } async *run(args: CodexExecArgs): AsyncGenerator { const commandArgs: string[] = ["exec", "--experimental-json"]; if (this.configOverrides) { for (const override of serializeConfigOverrides(this.configOverrides)) { commandArgs.push("--config", override); } } if (this.rawConfigOverrides) { for (const override of this.rawConfigOverrides) { commandArgs.push("--config", override); } } if (args.baseUrl) { commandArgs.push( "--config", `openai_base_url=${toTomlValue(args.baseUrl, "openai_base_url")}`, ); } if (args.model) { commandArgs.push("--model", args.model); } if (args.threadSource !== undefined && !args.threadId) { commandArgs.push("--thread-source", args.threadSource); } if (args.sandboxMode) { commandArgs.push("--sandbox", args.sandboxMode); } if (args.workingDirectory) { commandArgs.push("--cd", args.workingDirectory); } if (args.additionalDirectories?.length) { for (const dir of args.additionalDirectories) { commandArgs.push("--add-dir", dir); } } if (args.skipGitRepoCheck) { commandArgs.push("--skip-git-repo-check"); } if (args.outputSchemaFile) { commandArgs.push("--output-schema", args.outputSchemaFile); } if (args.cyberAccessProgram !== undefined) { commandArgs.push("--cyber-access-program", args.cyberAccessProgram); } if (args.modelReasoningEffort) { commandArgs.push("--config", `model_reasoning_effort="${args.modelReasoningEffort}"`); } if (args.networkAccessEnabled !== undefined) { commandArgs.push( "--config", `sandbox_workspace_write.network_access=${args.networkAccessEnabled}`, ); } if (args.webSearchMode) { commandArgs.push("--config", `web_search="${args.webSearchMode}"`); } else if (args.webSearchEnabled === true) { commandArgs.push("--config", `web_search="live"`); } else if (args.webSearchEnabled === false) { commandArgs.push("--config", `web_search="disabled"`); } if (args.approvalPolicy) { commandArgs.push("--config", `approval_policy="${args.approvalPolicy}"`); } if (args.threadId) { commandArgs.push("resume", args.threadId); } if (args.images?.length) { for (const image of args.images) { commandArgs.push("--image", image); } } const env: Record = {}; if (this.envOverride) { Object.assign(env, this.envOverride); } else { for (const [key, value] of Object.entries(process.env)) { if (value !== undefined) { env[key] = value; } } } if (!env[INTERNAL_ORIGINATOR_ENV]) { env[INTERNAL_ORIGINATOR_ENV] = TYPESCRIPT_SDK_ORIGINATOR; } if (args.apiKey) { env.CODEX_API_KEY = args.apiKey; } if (this.pathDirs.length > 0) { prependPathDirs(env, this.pathDirs); } const child = spawn(this.executablePath, commandArgs, { env, signal: args.signal, }); let spawnError: unknown | null = null; child.once("error", (err) => (spawnError = err)); if (!child.stdin) { child.kill(); throw new Error("Child process has no stdin"); } child.stdin.write(args.input); child.stdin.end(); if (!child.stdout) { child.kill(); throw new Error("Child process has no stdout"); } const stderrChunks: Buffer[] = []; if (child.stderr) { child.stderr.on("data", (data) => { stderrChunks.push(data); }); } const exitPromise = new Promise<{ code: number | null; signal: NodeJS.Signals | null }>( (resolve) => { child.once("exit", (code, signal) => { resolve({ code, signal }); }); }, ); const rl = readline.createInterface({ input: child.stdout, crlfDelay: Infinity, }); try { for await (const line of rl) { // `line` is a string (Node sets default encoding to utf8 for readline) yield line as string; } if (spawnError) throw spawnError; const { code, signal } = await exitPromise; if (code !== 0 || signal) { const stderrBuffer = Buffer.concat(stderrChunks); const detail = signal ? `signal ${signal}` : `code ${code ?? 1}`; throw new Error(`Codex Exec exited with ${detail}: ${stderrBuffer.toString("utf8")}`); } } finally { rl.close(); child.removeAllListeners(); try { if (!child.killed) child.kill(); } catch { // ignore } } } } function serializeConfigOverrides(configOverrides: CodexConfigObject): string[] { const overrides: string[] = []; flattenConfigOverrides(configOverrides, "", overrides); return overrides; } function flattenConfigOverrides( value: CodexConfigValue, prefix: string, overrides: string[], ): void { if (!isPlainObject(value)) { if (prefix) { overrides.push(`${prefix}=${toTomlValue(value, prefix)}`); return; } else { throw new Error("Codex config overrides must be a plain object"); } } const entries = Object.entries(value); if (!prefix && entries.length === 0) { return; } if (prefix && entries.length === 0) { overrides.push(`${prefix}={}`); return; } for (const [key, child] of entries) { if (!key) { throw new Error("Codex config override keys must be non-empty strings"); } if (child === undefined) { continue; } const path = prefix ? `${prefix}.${key}` : key; if (isPlainObject(child)) { flattenConfigOverrides(child, path, overrides); } else { overrides.push(`${path}=${toTomlValue(child, path)}`); } } } function toTomlValue(value: CodexConfigValue, path: string): string { if (typeof value === "string") { return JSON.stringify(value); } else if (typeof value === "number") { if (!Number.isFinite(value)) { throw new Error(`Codex config override at ${path} must be a finite number`); } return `${value}`; } else if (typeof value === "boolean") { return value ? "true" : "false"; } else if (Array.isArray(value)) { const rendered = value.map((item, index) => toTomlValue(item, `${path}[${index}]`)); return `[${rendered.join(", ")}]`; } else if (isPlainObject(value)) { const parts: string[] = []; for (const [key, child] of Object.entries(value)) { if (!key) { throw new Error("Codex config override keys must be non-empty strings"); } if (child === undefined) { continue; } parts.push(`${formatTomlKey(key)} = ${toTomlValue(child, `${path}.${key}`)}`); } return `{${parts.join(", ")}}`; } else if (value === null) { throw new Error(`Codex config override at ${path} cannot be null`); } else { const typeName = typeof value; throw new Error(`Unsupported Codex config override value at ${path}: ${typeName}`); } } const TOML_BARE_KEY = /^[A-Za-z0-9_-]+$/; function formatTomlKey(key: string): string { return TOML_BARE_KEY.test(key) ? key : JSON.stringify(key); } function isPlainObject(value: unknown): value is CodexConfigObject { return typeof value === "object" && value !== null && !Array.isArray(value); } function findCodexPath(): CodexPathResolution { const { platform, arch } = process; let targetTriple = null; switch (platform) { case "linux": case "android": switch (arch) { case "x64": targetTriple = "x86_64-unknown-linux-musl"; break; case "arm64": targetTriple = "aarch64-unknown-linux-musl"; break; default: break; } break; case "darwin": switch (arch) { case "x64": targetTriple = "x86_64-apple-darwin"; break; case "arm64": targetTriple = "aarch64-apple-darwin"; break; default: break; } break; case "win32": switch (arch) { case "x64": targetTriple = "x86_64-pc-windows-msvc"; break; case "arm64": targetTriple = "aarch64-pc-windows-msvc"; break; default: break; } break; default: break; } if (!targetTriple) { throw new Error(`Unsupported platform: ${platform} (${arch})`); } const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple]; if (!platformPackage) { throw new Error(`Unsupported target triple: ${targetTriple}`); } let vendorRoot: string; try { const codexPackageJsonPath = moduleRequire.resolve(`${CODEX_NPM_NAME}/package.json`); const codexRequire = createRequire(codexPackageJsonPath); const platformPackageJsonPath = codexRequire.resolve(`${platformPackage}/package.json`); vendorRoot = path.join(path.dirname(platformPackageJsonPath), "vendor"); } catch { throw new Error( `Unable to locate Codex CLI binaries. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`, ); } const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex"; const nativePackage = resolveNativePackage(vendorRoot, targetTriple, codexBinaryName); if (!nativePackage) { throw new Error( `Unable to locate Codex CLI binaries for ${targetTriple}. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`, ); } return nativePackage; } export function resolveNativePackage( vendorRoot: string, targetTriple: string, codexBinaryName: string, ): CodexPathResolution | null { const packageRoot = path.join(vendorRoot, targetTriple); const packageBinaryPath = path.join(packageRoot, "bin", codexBinaryName); if (isFile(packageBinaryPath) && isFile(path.join(packageRoot, "codex-package.json"))) { return { executablePath: packageBinaryPath, pathDirs: existingDirs(path.join(packageRoot, "codex-path")), }; } const legacyBinaryPath = path.join(packageRoot, "codex", codexBinaryName); if (isFile(legacyBinaryPath)) { return { executablePath: legacyBinaryPath, pathDirs: existingDirs(path.join(packageRoot, "path")), }; } return null; } function existingDirs(...dirs: string[]): string[] { return dirs.filter(isDirectory); } export function prependPathDirs( env: Record, pathDirs: string[], platform: NodeJS.Platform = process.platform, ): void { const pathKey = pathEnvKey(env, platform); if (platform === "win32") { for (const key of Object.keys(env)) { if (key.toLowerCase() === "path" && key !== pathKey) { delete env[key]; } } } const existingEntries = (env[pathKey] ?? "") .split(path.delimiter) .filter((entry) => entry.length > 0 && !pathDirs.includes(entry)); env[pathKey] = [...pathDirs, ...existingEntries].join(path.delimiter); } function pathEnvKey(env: Record, platform: NodeJS.Platform): string { if (platform !== "win32") { return "PATH"; } const matchingKeys = Object.keys(env).filter((key) => key.toLowerCase() === "path"); return matchingKeys.includes("Path") ? "Path" : (matchingKeys.at(-1) ?? "PATH"); } function isFile(filePath: string): boolean { try { return statSync(filePath).isFile(); } catch { return false; } } function isDirectory(filePath: string): boolean { try { return statSync(filePath).isDirectory(); } catch { return false; } }