copilot-hub 0.1.20 → 0.1.21

package/scripts/dist/codex-runtime.mjs

@@ -0,0 +1,352 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+import { compareSemver, codexVersionRequirementLabel, extractSemver, isCodexVersionCompatible, } from "./codex-version.mjs";
+export function resolveCodexBinForStart({ repoRoot, agentEngineEnvPath, controlPlaneEnvPath, env = process.env, }) {
+    const fromEnv = nonEmpty(env.CODEX_BIN);
+    if (fromEnv) {
+        return buildResolvedCodexBin({
+            value: fromEnv,
+            source: "process_env",
+            env,
+            repoRoot,
+        });
+    }
+    for (const [source, envPath] of [
+        ["agent_env", agentEngineEnvPath],
+        ["control_plane_env", controlPlaneEnvPath],
+    ]) {
+        const value = readEnvValue(envPath, "CODEX_BIN");
+        if (value) {
+            return buildResolvedCodexBin({
+                value,
+                source,
+                env,
+                repoRoot,
+            });
+        }
+    }
+    const detected = findDetectedCodexBin(env, repoRoot);
+    if (detected) {
+        return {
+            bin: detected,
+            source: "detected",
+            userConfigured: false,
+        };
+    }
+    return {
+        bin: "codex",
+        source: "default",
+        userConfigured: false,
+    };
+}
+export function resolveCompatibleInstalledCodexBin({ repoRoot, env = process.env, }) {
+    const matches = [];
+    for (const candidate of listCodexBinCandidates(env, repoRoot)) {
+        const probe = probeCodexVersion({
+            codexBin: candidate,
+            repoRoot,
+        });
+        if (!probe.ok || !probe.compatible) {
+            continue;
+        }
+        matches.push({
+            candidate,
+            version: probe.version,
+            priority: getCodexCandidatePriority(candidate, env, repoRoot),
+        });
+    }
+    if (matches.length === 0) {
+        return "";
+    }
+    matches.sort((left, right) => {
+        const versionOrder = compareSemver(right.version, left.version);
+        if (versionOrder !== 0) {
+            return versionOrder;
+        }
+        return left.priority - right.priority;
+    });
+    return matches[0]?.candidate ?? "";
+}
+export function probeCodexVersion({ codexBin, repoRoot, }) {
+    const status = runCodex({
+        codexBin,
+        args: ["--version"],
+        repoRoot,
+    });
+    if (!status.ok) {
+        return {
+            ...status,
+            version: "",
+            rawVersion: "",
+            compatible: false,
+        };
+    }
+    const rawVersion = firstLine(status.stdout) || firstLine(status.stderr);
+    const version = extractSemver(rawVersion);
+    if (!version) {
+        return {
+            ok: false,
+            stdout: status.stdout,
+            stderr: status.stderr,
+            errorMessage: `Could not parse Codex version from '${rawVersion || "empty output"}'.`,
+            errorCode: "INVALID_VERSION",
+            version: "",
+            rawVersion,
+            compatible: false,
+        };
+    }
+    return {
+        ...status,
+        version,
+        rawVersion,
+        compatible: isCodexVersionCompatible(version),
+    };
+}
+export function buildCodexCompatibilitySummary({ resolved, probe, }) {
+    if (probe.ok) {
+        return `Codex binary '${resolved.bin}' is version ${probe.version}.`;
+    }
+    if (probe.errorCode === "ENOENT") {
+        return `Codex binary '${resolved.bin}' was not found.`;
+    }
+    return probe.errorMessage || `Codex binary '${resolved.bin}' is not usable.`;
+}
+export function buildCodexCompatibilityNotice({ resolved, probe, }) {
+    return [
+        buildCodexCompatibilitySummary({ resolved, probe }),
+        `copilot-hub requires Codex CLI ${codexVersionRequirementLabel}.`,
+    ].join("\n");
+}
+export function buildCodexCompatibilityError({ resolved, probe, includeInstallHint, installCommand, }) {
+    const lines = [
+        buildCodexCompatibilitySummary({ resolved, probe }),
+        `copilot-hub requires Codex CLI ${codexVersionRequirementLabel}.`,
+    ];
+    if (includeInstallHint) {
+        lines.push(`Install a compatible version with '${installCommand}', then retry.`);
+    }
+    else {
+        lines.push("Update that binary or point CODEX_BIN to a compatible executable, then retry.");
+    }
+    return lines.join("\n");
+}
+function buildResolvedCodexBin({ value, source, env, repoRoot, }) {
+    const normalized = String(value ?? "")
+        .trim()
+        .toLowerCase();
+    if (normalized && normalized !== "codex") {
+        return {
+            bin: value,
+            source,
+            userConfigured: true,
+        };
+    }
+    const detected = findDetectedCodexBin(env, repoRoot);
+    return {
+        bin: detected || "codex",
+        source,
+        userConfigured: false,
+    };
+}
+function findDetectedCodexBin(env, repoRoot) {
+    if (process.platform !== "win32") {
+        return "";
+    }
+    return findWindowsNpmGlobalCodexBin(env, repoRoot) || findVscodeCodexExe(env) || "";
+}
+function listCodexBinCandidates(env, repoRoot) {
+    return dedupe(["codex", findWindowsNpmGlobalCodexBin(env, repoRoot), findVscodeCodexExe(env)]);
+}
+function getCodexCandidatePriority(candidate, env, repoRoot) {
+    if (candidate === "codex") {
+        return 0;
+    }
+    const npmGlobal = findWindowsNpmGlobalCodexBin(env, repoRoot);
+    if (npmGlobal && candidate === npmGlobal) {
+        return 1;
+    }
+    const vscode = findVscodeCodexExe(env);
+    if (vscode && candidate === vscode) {
+        return 2;
+    }
+    return 3;
+}
+function findVscodeCodexExe(env) {
+    const userProfile = nonEmpty(env.USERPROFILE);
+    if (!userProfile) {
+        return "";
+    }
+    const extensionsDir = path.join(userProfile, ".vscode", "extensions");
+    if (!fs.existsSync(extensionsDir)) {
+        return "";
+    }
+    const candidates = fs
+        .readdirSync(extensionsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .filter((name) => name.startsWith("openai.chatgpt-"))
+        .sort()
+        .reverse();
+    for (const folder of candidates) {
+        const exePath = path.join(extensionsDir, folder, "bin", "windows-x86_64", "codex.exe");
+        if (fs.existsSync(exePath)) {
+            return exePath;
+        }
+    }
+    return "";
+}
+function findWindowsNpmGlobalCodexBin(env, repoRoot) {
+    if (process.platform !== "win32") {
+        return "";
+    }
+    const candidates = [];
+    const appData = nonEmpty(env.APPDATA);
+    if (appData) {
+        candidates.push(path.join(appData, "npm", "codex.cmd"));
+        candidates.push(path.join(appData, "npm", "codex.exe"));
+        candidates.push(path.join(appData, "npm", "codex"));
+    }
+    const npmPrefix = readNpmPrefix(repoRoot);
+    if (npmPrefix) {
+        candidates.push(path.join(npmPrefix, "codex.cmd"));
+        candidates.push(path.join(npmPrefix, "codex.exe"));
+        candidates.push(path.join(npmPrefix, "codex"));
+    }
+    for (const candidate of dedupe(candidates)) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return "";
+}
+function readNpmPrefix(repoRoot) {
+    const result = spawnNpm(["config", "get", "prefix"], repoRoot);
+    if (result.error || result.status !== 0) {
+        return "";
+    }
+    const value = String(result.stdout ?? "").trim();
+    if (!value || value.toLowerCase() === "undefined") {
+        return "";
+    }
+    return value;
+}
+function runCodex({ codexBin, args, repoRoot, }) {
+    const result = spawnCodex(codexBin, args, repoRoot);
+    if (result.error) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: "",
+            errorMessage: formatCodexSpawnError(codexBin, result.error),
+            errorCode: normalizeErrorCode(result.error),
+        };
+    }
+    const code = Number.isInteger(result.status) ? result.status : 1;
+    return {
+        ok: code === 0,
+        stdout: String(result.stdout ?? "").trim(),
+        stderr: String(result.stderr ?? "").trim(),
+        errorMessage: "",
+        errorCode: "",
+    };
+}
+function spawnCodex(codexBin, args, repoRoot) {
+    if (process.platform === "win32" && /\.(cmd|bat)$/i.test(codexBin)) {
+        const commandLine = [
+            quoteWindowsShellValue(codexBin),
+            ...args.map(quoteWindowsShellValue),
+        ].join(" ");
+        return spawnSync(commandLine, {
+            cwd: repoRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: true,
+            encoding: "utf8",
+        });
+    }
+    return spawnSync(codexBin, args, {
+        cwd: repoRoot,
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false,
+        encoding: "utf8",
+    });
+}
+function readEnvValue(filePath, key) {
+    if (!fs.existsSync(filePath)) {
+        return "";
+    }
+    const lines = fs.readFileSync(filePath, "utf8").split(/\r?\n/);
+    const pattern = new RegExp(`^\\s*${escapeRegex(key)}\\s*=\\s*(.*)\\s*$`);
+    for (const line of lines) {
+        const match = line.match(pattern);
+        if (!match) {
+            continue;
+        }
+        return unquote(match[1]);
+    }
+    return "";
+}
+function unquote(value) {
+    const raw = String(value ?? "").trim();
+    if (!raw) {
+        return "";
+    }
+    if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
+        return raw.slice(1, -1).trim();
+    }
+    return raw;
+}
+function escapeRegex(value) {
+    return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function nonEmpty(value) {
+    const normalized = String(value ?? "").trim();
+    return normalized || "";
+}
+function firstLine(value) {
+    return (String(value ?? "")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean) ?? "");
+}
+function formatCodexSpawnError(command, error) {
+    const code = normalizeErrorCode(error);
+    if (code === "ENOENT") {
+        return `Codex binary '${command}' was not found. Install Codex CLI or set CODEX_BIN.`;
+    }
+    if (code === "EPERM") {
+        return `Codex binary '${command}' cannot be executed (EPERM). Check permissions or CODEX_BIN.`;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return `Failed to execute '${command}': ${firstLine(message)}`;
+}
+function normalizeErrorCode(error) {
+    return String(error?.code ?? "")
+        .trim()
+        .toUpperCase();
+}
+function dedupe(values) {
+    return [...new Set(values.map((value) => String(value ?? "").trim()).filter(Boolean))];
+}
+function quoteWindowsShellValue(value) {
+    return `"${String(value ?? "").replace(/"/g, '\\"')}"`;
+}
+function spawnNpm(args, repoRoot) {
+    if (process.platform === "win32") {
+        const comspec = process.env.ComSpec || "cmd.exe";
+        const commandLine = ["npm", ...args].join(" ");
+        return spawnSync(comspec, ["/d", "/s", "/c", commandLine], {
+            cwd: repoRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: false,
+            encoding: "utf8",
+        });
+    }
+    return spawnSync("npm", args, {
+        cwd: repoRoot,
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false,
+        encoding: "utf8",
+    });
+}

package/scripts/dist/codex-version.mjs

@@ -0,0 +1,91 @@
+export const codexNpmPackage = "@openai/codex";
+export const minimumCodexVersion = "0.113.0";
+export const maximumCodexVersionExclusive = "0.114.0";
+export const codexInstallPackageSpec = `${codexNpmPackage}@${minimumCodexVersion}`;
+export const codexVersionRequirementLabel = `>= ${minimumCodexVersion} < ${maximumCodexVersionExclusive}`;
+export function extractSemver(value) {
+    const match = String(value ?? "").match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?/);
+    return String(match?.[0] ?? "").trim();
+}
+export function compareSemver(left, right) {
+    const a = parseSemver(left);
+    const b = parseSemver(right);
+    if (!a || !b) {
+        return 0;
+    }
+    if (a.major !== b.major) {
+        return a.major > b.major ? 1 : -1;
+    }
+    if (a.minor !== b.minor) {
+        return a.minor > b.minor ? 1 : -1;
+    }
+    if (a.patch !== b.patch) {
+        return a.patch > b.patch ? 1 : -1;
+    }
+    if (a.prerelease.length === 0 && b.prerelease.length === 0) {
+        return 0;
+    }
+    if (a.prerelease.length === 0) {
+        return 1;
+    }
+    if (b.prerelease.length === 0) {
+        return -1;
+    }
+    const maxLength = Math.max(a.prerelease.length, b.prerelease.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftPart = a.prerelease[index];
+        const rightPart = b.prerelease[index];
+        if (leftPart === undefined) {
+            return -1;
+        }
+        if (rightPart === undefined) {
+            return 1;
+        }
+        if (leftPart === rightPart) {
+            continue;
+        }
+        const leftNumeric = /^\d+$/.test(leftPart);
+        const rightNumeric = /^\d+$/.test(rightPart);
+        if (leftNumeric && rightNumeric) {
+            const leftValue = Number.parseInt(leftPart, 10);
+            const rightValue = Number.parseInt(rightPart, 10);
+            if (leftValue !== rightValue) {
+                return leftValue > rightValue ? 1 : -1;
+            }
+            continue;
+        }
+        if (leftNumeric) {
+            return -1;
+        }
+        if (rightNumeric) {
+            return 1;
+        }
+        return leftPart > rightPart ? 1 : -1;
+    }
+    return 0;
+}
+export function isCodexVersionCompatible(version) {
+    const parsed = parseSemver(version);
+    if (!parsed || parsed.prerelease.length > 0) {
+        return false;
+    }
+    return (compareSemver(version, minimumCodexVersion) >= 0 &&
+        compareSemver(version, maximumCodexVersionExclusive) < 0);
+}
+function parseSemver(value) {
+    const normalized = extractSemver(value);
+    const match = normalized.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+    if (!match) {
+        return null;
+    }
+    const prerelease = String(match[4] ?? "")
+        .split(".")
+        .map((part) => part.trim())
+        .filter(Boolean);
+    return {
+        major: Number.parseInt(match[1] ?? "", 10),
+        minor: Number.parseInt(match[2] ?? "", 10),
+        patch: Number.parseInt(match[3] ?? "", 10),
+        prerelease,
+    };
+}

package/scripts/dist/daemon.mjs

@@ -5,6 +5,8 @@ import process from "node:process";
 import { spawn, spawnSync } from "node:child_process";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
+import { codexInstallPackageSpec } from "./codex-version.mjs";
+import { buildCodexCompatibilityError, probeCodexVersion, resolveCodexBinForStart, resolveCompatibleInstalledCodexBin, } from "./codex-runtime.mjs";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const repoRoot = path.resolve(__dirname, "..", "..");
@@ -19,6 +21,9 @@ const agentEngineLogPath = path.join(logsDir, "agent-engine.log");
 const daemonScriptPath = path.join(repoRoot, "scripts", "dist", "daemon.mjs");
 const supervisorScriptPath = path.join(repoRoot, "scripts", "dist", "supervisor.mjs");
 const nodeBin = process.execPath;
+const agentEngineEnvPath = path.join(repoRoot, "apps", "agent-engine", ".env");
+const controlPlaneEnvPath = path.join(repoRoot, "apps", "control-plane", ".env");
+const codexInstallCommand = `npm install -g ${codexInstallPackageSpec}`;
 const BASE_CHECK_MS = 5000;
 const MAX_BACKOFF_MS = 60000;
 const action = String(process.argv[2] ?? "status")
@@ -103,6 +108,26 @@ async function runDaemonLoop() {
     });
     const state = { stopping: false, shuttingDown: false };
     setupSignalHandlers(state);
+    try {
+        ensureCompatibleCodexForDaemon();
+        clearLastStartupError();
+    }
+    catch (error) {
+        writeLastStartupError({
+            detectedAt: new Date().toISOString(),
+            reason: getErrorMessage(error),
+            action: buildCodexCompatibilityAction(error),
+        });
+        console.error(`[daemon] fatal startup error: ${getErrorMessage(error)}`);
+        console.error(`[daemon] action required: ${buildCodexCompatibilityAction(error)}`);
+        state.stopping = true;
+        await shutdownDaemon(state, {
+            reason: "fatal-codex-compatibility",
+            exitCode: 1,
+            pauseBeforeExit: true,
+        });
+        return;
+    }
     console.log(`[daemon] running (pid ${process.pid})`);
     let failureCount = 0;
     while (!state.stopping) {
@@ -529,6 +554,39 @@ function printLastStartupError() {
         console.log(`action: ${String(issue.action)}`);
     }
 }
+function ensureCompatibleCodexForDaemon() {
+    const resolved = resolveCodexBinForStart({
+        repoRoot,
+        agentEngineEnvPath,
+        controlPlaneEnvPath,
+    });
+    const currentProbe = probeCodexVersion({
+        codexBin: resolved.bin,
+        repoRoot,
+    });
+    if (currentProbe.ok && currentProbe.compatible) {
+        return;
+    }
+    if (!resolved.userConfigured) {
+        const compatibleInstalled = resolveCompatibleInstalledCodexBin({ repoRoot });
+        if (compatibleInstalled) {
+            return;
+        }
+    }
+    throw new Error(buildCodexCompatibilityError({
+        resolved,
+        probe: currentProbe,
+        includeInstallHint: !resolved.userConfigured,
+        installCommand: codexInstallCommand,
+    }));
+}
+function buildCodexCompatibilityAction(error) {
+    const message = getErrorMessage(error);
+    if (message.includes("Install a compatible version with")) {
+        return `Install a compatible version with '${codexInstallCommand}', then restart the service.`;
+    }
+    return "Update that binary or point CODEX_BIN to a compatible executable, then restart the service.";
+}
 function printUsage() {
     console.log("Usage: node scripts/dist/daemon.mjs <start|run|stop|status|help>");
 }