codex-runner.js

import { spawn } from "node:child_process";
import { join } from "node:path";

const ALLOWED_SANDBOXES = new Set(["read-only", "workspace-write"]);
const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;

export function getCodexBin(platform = process.platform) {
  return platform === "win32" ? "codex.cmd" : "codex";
}

export function getWindowsCodexScript(env = process.env) {
  if (!env.APPDATA) {
    return null;
  }
  return join(env.APPDATA, "npm", "node_modules", "@openai", "codex", "bin", "codex.js");
}

export function buildCodexSpawn(args, platform = process.platform, env = process.env) {
  if (platform === "win32") {
    const script = getWindowsCodexScript(env);
    if (script) {
      return {
        bin: "node",
        args: [script, ...args],
      };
    }

    return {
      bin: "cmd.exe",
      args: ["/d", "/s", "/c", getCodexBin(platform), ...args],
    };
  }

  return {
    bin: getCodexBin(platform),
    args,
  };
}

export function buildCodexArgs(input) {
  const sandbox = ALLOWED_SANDBOXES.has(input.sandbox)
    ? input.sandbox
    : "read-only";

  const args = [
    "exec",
    "--color",
    "never",
    "--sandbox",
    sandbox,
    "--skip-git-repo-check",
    "--ephemeral",
  ];
  if (input.model) {
    args.push("--model", input.model);
  }
  if (input.cwd) {
    args.push("--cd", input.cwd);
  }
  args.push(input.prompt);
  return args;
}

export function runCodexExec(input, options = {}) {
  const timeoutMs = Number(input.timeoutMs ?? options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
  const args = buildCodexArgs(input);

  return new Promise((resolve) => {
    let stdout = "";
    let stderr = "";
    let timedOut = false;
    let child;

    try {
      const spawnConfig = options.bin
        ? { bin: options.bin, args }
        : buildCodexSpawn(args);
      child = spawn(spawnConfig.bin, spawnConfig.args, {
        cwd: options.cwd ?? process.cwd(),
        shell: false,
        stdio: ["ignore", "pipe", "pipe"],
        windowsHide: true,
      });
    } catch (error) {
      resolve({
        stdout,
        stderr: error instanceof Error ? error.message : String(error),
        exitCode: 1,
        timedOut,
      });
      return;
    }

    const timer = setTimeout(() => {
      timedOut = true;
      child.kill("SIGTERM");
    }, timeoutMs);

    child.stdout.on("data", (chunk) => {
      stdout += chunk.toString();
    });

    child.stderr.on("data", (chunk) => {
      stderr += chunk.toString();
    });

    child.on("error", (error) => {
      clearTimeout(timer);
      resolve({
        stdout,
        stderr: stderr || error.message,
        exitCode: 1,
        timedOut,
      });
    });

    child.on("close", (exitCode) => {
      clearTimeout(timer);
      resolve({
        stdout,
        stderr,
        exitCode,
        timedOut,
      });
    });
  });
}