copilot-hub 0.1.25 → 0.1.28

package/apps/agent-engine/dist/config.js

@@ -146,7 +146,7 @@ function resolveCodexBin(rawValue) {
     const value = String(rawValue ?? "").trim();
     const normalized = value.toLowerCase();
     if (value && normalized !== "codex") {
-        return value;
+        return normalizeConfiguredCodexBin(value);
     }
     if (process.platform === "win32") {
         const npmGlobalCodex = findWindowsNpmGlobalCodexBin();
@@ -160,6 +160,24 @@ function resolveCodexBin(rawValue) {
     }
     return value || "codex";
 }
+function normalizeConfiguredCodexBin(value) {
+    const normalizedValue = String(value ?? "").trim();
+    if (process.platform !== "win32" || !normalizedValue) {
+        return normalizedValue;
+    }
+    const basename = path.win32.basename(normalizedValue).toLowerCase();
+    if (basename !== "codex.cmd" && basename !== "codex.bat") {
+        return normalizedValue;
+    }
+    if (path.win32.isAbsolute(normalizedValue)) {
+        const wrapperDir = path.win32.dirname(normalizedValue);
+        const entrypoint = path.win32.join(wrapperDir, "node_modules", "@openai", "codex", "bin", "codex.js");
+        if (fs.existsSync(entrypoint)) {
+            return entrypoint;
+        }
+    }
+    return findWindowsNpmGlobalCodexBin() || normalizedValue;
+}
 function findVscodeCodexExe() {
     const userProfile = process.env.USERPROFILE;
     if (!userProfile) {

package/apps/control-plane/dist/config.js

@@ -153,7 +153,7 @@ function resolveCodexBin(rawValue) {
     const value = String(rawValue ?? "").trim();
     const normalized = value.toLowerCase();
     if (value && normalized !== "codex") {
-        return value;
+        return normalizeConfiguredCodexBin(value);
     }
     if (process.platform === "win32") {
         const npmGlobalCodex = findWindowsNpmGlobalCodexBin();
@@ -167,6 +167,24 @@ function resolveCodexBin(rawValue) {
     }
     return value || "codex";
 }
+function normalizeConfiguredCodexBin(value) {
+    const normalizedValue = String(value ?? "").trim();
+    if (process.platform !== "win32" || !normalizedValue) {
+        return normalizedValue;
+    }
+    const basename = path.win32.basename(normalizedValue).toLowerCase();
+    if (basename !== "codex.cmd" && basename !== "codex.bat") {
+        return normalizedValue;
+    }
+    if (path.win32.isAbsolute(normalizedValue)) {
+        const wrapperDir = path.win32.dirname(normalizedValue);
+        const entrypoint = path.win32.join(wrapperDir, "node_modules", "@openai", "codex", "bin", "codex.js");
+        if (fs.existsSync(entrypoint)) {
+            return entrypoint;
+        }
+    }
+    return findWindowsNpmGlobalCodexBin() || normalizedValue;
+}
 function findVscodeCodexExe() {
     const userProfile = process.env.USERPROFILE;
     if (!userProfile) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-hub",
-  "version": "0.1.25",
+  "version": "0.1.28",
   "description": "Copilot Hub CLI and runtime bundle",
   "license": "MIT",
   "repository": {

package/scripts/dist/cli.mjs

@@ -5,6 +5,7 @@ import process, { stdin as input, stdout as output } from "node:process";
 import { spawnSync } from "node:child_process";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
+import { spawnCodexSync } from "./codex-spawn.mjs";
 import { codexInstallPackageSpec } from "./codex-version.mjs";
 import { initializeCopilotHubLayout, resolveCopilotHubLayout } from "./install-layout.mjs";
 import { buildCodexCompatibilityError, buildCodexCompatibilityNotice, probeCodexVersion, resolveCodexBinForStart, resolveCompatibleInstalledCodexBin, } from "./codex-runtime.mjs";
@@ -367,22 +368,13 @@ async function ensureCompatibleCodexBinary({ autoInstall, purpose, }) {
 }
 function runCodex(codexBin, args, stdioMode) {
     const stdio = stdioMode === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"];
-    const result = process.platform === "win32" && /\.(cmd|bat)$/i.test(String(codexBin ?? ""))
-        ? spawnSync([
-            quoteWindowsShellValue(codexBin),
-            ...args.map((arg) => quoteWindowsShellValue(arg)),
-        ].join(" "), {
-            cwd: repoRoot,
-            stdio,
-            shell: true,
-            encoding: "utf8",
-        })
-        : spawnSync(codexBin, args, {
-            cwd: repoRoot,
-            stdio,
-            shell: false,
-            encoding: "utf8",
-        });
+    const result = spawnCodexSync({
+        codexBin,
+        args,
+        cwd: repoRoot,
+        stdio,
+        encoding: "utf8",
+    });
     if (result.error) {
         return {
             ok: false,
@@ -401,9 +393,6 @@ function runCodex(codexBin, args, stdioMode) {
         errorCode: "",
     };
 }
-function quoteWindowsShellValue(value) {
-    return `"${String(value ?? "").replace(/"/g, '\\"')}"`;
-}
 function runNpm(args, stdioMode) {
     const stdio = stdioMode === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"];
     const result = spawnNpm(args, {

package/scripts/dist/codex-runtime.mjs

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { spawnSync } from "node:child_process";
+import { spawnCodexSync } from "./codex-spawn.mjs";
 import { compareSemver, codexVersionRequirementLabel, extractSemver, isCodexVersionCompatible, } from "./codex-version.mjs";
 export function resolveCodexBinForStart({ repoRoot, agentEngineEnvPath, controlPlaneEnvPath, env = process.env, }) {
     const fromEnv = nonEmpty(env.CODEX_BIN);
@@ -41,9 +42,9 @@ export function resolveCodexBinForStart({ repoRoot, agentEngineEnvPath, controlP
         userConfigured: false,
     };
 }
-export function resolveCompatibleInstalledCodexBin({ repoRoot, env = process.env, }) {
+export function resolveCompatibleInstalledCodexBin({ repoRoot, env = process.env, platform = process.platform, }) {
     const matches = [];
-    for (const candidate of listCodexBinCandidates(env, repoRoot)) {
+    for (const candidate of listCodexBinCandidates(env, repoRoot, platform)) {
         const probe = probeCodexVersion({
             codexBin: candidate,
             repoRoot,
@@ -54,7 +55,7 @@ export function resolveCompatibleInstalledCodexBin({ repoRoot, env = process.env
         matches.push({
             candidate,
             version: probe.version,
-            priority: getCodexCandidatePriority(candidate, env, repoRoot),
+            priority: getCodexCandidatePriority(candidate, env, repoRoot, platform),
         });
     }
     if (matches.length === 0) {
@@ -133,12 +134,17 @@ export function buildCodexCompatibilityError({ resolved, probe, includeInstallHi
     return lines.join("\n");
 }
 function buildResolvedCodexBin({ value, source, env, repoRoot, }) {
-    const normalized = String(value ?? "")
+    const normalizedValue = normalizeConfiguredCodexBin({
+        value,
+        env,
+        repoRoot,
+    });
+    const normalized = String(normalizedValue ?? "")
         .trim()
         .toLowerCase();
     if (normalized && normalized !== "codex") {
         return {
-            bin: value,
+            bin: normalizedValue,
             source,
             userConfigured: true,
         };
@@ -150,20 +156,43 @@ function buildResolvedCodexBin({ value, source, env, repoRoot, }) {
         userConfigured: false,
     };
 }
+export function normalizeConfiguredCodexBin({ value, env = process.env, repoRoot, platform = process.platform, }) {
+    const normalizedValue = String(value ?? "").trim();
+    if (!normalizedValue || platform !== "win32") {
+        return normalizedValue;
+    }
+    const normalizedBasename = path.win32.basename(normalizedValue).toLowerCase();
+    if (normalizedBasename !== "codex.cmd" && normalizedBasename !== "codex.bat") {
+        return normalizedValue;
+    }
+    if (path.win32.isAbsolute(normalizedValue)) {
+        const pathModule = selectPathModule(normalizedValue);
+        const wrapperDir = pathModule.dirname(normalizedValue);
+        const entrypoint = pathModule.join(wrapperDir, "node_modules", "@openai", "codex", "bin", "codex.js");
+        if (fs.existsSync(entrypoint)) {
+            return entrypoint;
+        }
+    }
+    return findWindowsNpmGlobalCodexBin(env, repoRoot, platform) || normalizedValue;
+}
 function findDetectedCodexBin(env, repoRoot) {
     if (process.platform !== "win32") {
         return "";
     }
-    return findWindowsNpmGlobalCodexBin(env, repoRoot) || findVscodeCodexExe(env) || "";
+    return (findWindowsNpmGlobalCodexBin(env, repoRoot, process.platform) || findVscodeCodexExe(env) || "");
 }
-function listCodexBinCandidates(env, repoRoot) {
-    return dedupe(["codex", findWindowsNpmGlobalCodexBin(env, repoRoot), findVscodeCodexExe(env)]);
+function listCodexBinCandidates(env, repoRoot, platform) {
+    return dedupe([
+        "codex",
+        findWindowsNpmGlobalCodexBin(env, repoRoot, platform),
+        findVscodeCodexExe(env),
+    ]);
 }
-function getCodexCandidatePriority(candidate, env, repoRoot) {
+function getCodexCandidatePriority(candidate, env, repoRoot, platform) {
     if (candidate === "codex") {
         return 0;
     }
-    const npmGlobal = findWindowsNpmGlobalCodexBin(env, repoRoot);
+    const npmGlobal = findWindowsNpmGlobalCodexBin(env, repoRoot, platform);
     if (npmGlobal && candidate === npmGlobal) {
         return 1;
     }
@@ -197,8 +226,8 @@ function findVscodeCodexExe(env) {
     }
     return "";
 }
-function findWindowsNpmGlobalCodexBin(env, repoRoot) {
-    if (process.platform !== "win32") {
+function findWindowsNpmGlobalCodexBin(env, repoRoot, platform) {
+    if (platform !== "win32") {
         return "";
     }
     const packageRoots = [];
@@ -230,6 +259,13 @@ function findWindowsNpmGlobalCodexBin(env, repoRoot) {
     }
     return "";
 }
+function selectPathModule(filePath) {
+    const normalized = String(filePath ?? "").trim();
+    if (/^[A-Za-z]:[\\/]/.test(normalized) || normalized.includes("\\")) {
+        return path.win32;
+    }
+    return path.posix;
+}
 function readNpmPrefix(repoRoot) {
     const result = spawnNpm(["config", "get", "prefix"], repoRoot);
     if (result.error || result.status !== 0) {
@@ -262,30 +298,11 @@ function runCodex({ codexBin, args, repoRoot, }) {
     };
 }
 function spawnCodex(codexBin, args, repoRoot) {
-    if (/\.(cjs|mjs|js)$/i.test(codexBin)) {
-        return spawnSync(process.execPath, [codexBin, ...args], {
-            cwd: repoRoot,
-            stdio: ["ignore", "pipe", "pipe"],
-            shell: false,
-            encoding: "utf8",
-        });
-    }
-    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, {
+    return spawnCodexSync({
+        codexBin,
+        args,
         cwd: repoRoot,
         stdio: ["ignore", "pipe", "pipe"],
-        shell: false,
         encoding: "utf8",
     });
 }
@@ -346,9 +363,6 @@ function normalizeErrorCode(error) {
 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";

package/scripts/dist/codex-spawn.mjs

@@ -0,0 +1,42 @@
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+export function requiresNodeScriptCodexBin(command) {
+    return /\.(cjs|mjs|js)$/i.test(String(command ?? "").trim());
+}
+export function requiresShellWrappedCodexBin(command, platform = process.platform) {
+    return platform === "win32" && /\.(cmd|bat)$/i.test(String(command ?? "").trim());
+}
+export function buildCodexSpawnSpec({ codexBin, args, platform = process.platform, nodeBin = process.execPath, }) {
+    if (requiresNodeScriptCodexBin(codexBin)) {
+        return {
+            command: nodeBin,
+            args: [codexBin, ...args],
+            shell: false,
+        };
+    }
+    if (requiresShellWrappedCodexBin(codexBin, platform)) {
+        return {
+            command: [quoteWindowsShellValue(codexBin), ...args.map(quoteWindowsShellValue)].join(" "),
+            args: [],
+            shell: true,
+        };
+    }
+    return {
+        command: codexBin,
+        args: [...args],
+        shell: false,
+    };
+}
+export function spawnCodexSync({ codexBin, args, cwd, stdio, encoding = "utf8", input, }) {
+    const spec = buildCodexSpawnSpec({ codexBin, args });
+    return spawnSync(spec.command, spec.args, {
+        cwd,
+        stdio,
+        shell: spec.shell,
+        encoding,
+        ...(input !== undefined ? { input } : {}),
+    });
+}
+function quoteWindowsShellValue(value) {
+    return `"${String(value ?? "").replace(/"/g, '\\"')}"`;
+}

package/scripts/src/cli.mts

@@ -5,6 +5,7 @@ import process, { stdin as input, stdout as output } from "node:process";
 import { spawnSync } from "node:child_process";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
+import { spawnCodexSync } from "./codex-spawn.mjs";
 import { codexInstallPackageSpec } from "./codex-version.mjs";
 import { initializeCopilotHubLayout, resolveCopilotHubLayout } from "./install-layout.mjs";
 import {
@@ -443,26 +444,13 @@ async function ensureCompatibleCodexBinary({
 
 function runCodex(codexBin, args, stdioMode) {
   const stdio: any = stdioMode === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"];
-  const result =
-    process.platform === "win32" && /\.(cmd|bat)$/i.test(String(codexBin ?? ""))
-      ? spawnSync(
-          [
-            quoteWindowsShellValue(codexBin),
-            ...args.map((arg) => quoteWindowsShellValue(arg)),
-          ].join(" "),
-          {
-            cwd: repoRoot,
-            stdio,
-            shell: true,
-            encoding: "utf8",
-          },
-        )
-      : spawnSync(codexBin, args, {
-          cwd: repoRoot,
-          stdio,
-          shell: false,
-          encoding: "utf8",
-        });
+  const result = spawnCodexSync({
+    codexBin,
+    args,
+    cwd: repoRoot,
+    stdio,
+    encoding: "utf8",
+  });
 
   if (result.error) {
     return {
@@ -484,10 +472,6 @@ function runCodex(codexBin, args, stdioMode) {
   };
 }
 
-function quoteWindowsShellValue(value) {
-  return `"${String(value ?? "").replace(/"/g, '\\"')}"`;
-}
-
 function runNpm(args, stdioMode) {
   const stdio = stdioMode === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"];
   const result = spawnNpm(args, {

package/scripts/src/codex-runtime.mts

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { spawnSync } from "node:child_process";
+import { spawnCodexSync } from "./codex-spawn.mjs";
 import {
   compareSemver,
   codexVersionRequirementLabel,
@@ -81,13 +82,15 @@ export function resolveCodexBinForStart({
 export function resolveCompatibleInstalledCodexBin({
   repoRoot,
   env = process.env,
+  platform = process.platform,
 }: {
   repoRoot: string;
   env?: NodeJS.ProcessEnv;
+  platform?: NodeJS.Platform;
 }): string {
   const matches: Array<{ candidate: string; version: string; priority: number }> = [];
 
-  for (const candidate of listCodexBinCandidates(env, repoRoot)) {
+  for (const candidate of listCodexBinCandidates(env, repoRoot, platform)) {
     const probe = probeCodexVersion({
       codexBin: candidate,
       repoRoot,
@@ -99,7 +102,7 @@ export function resolveCompatibleInstalledCodexBin({
     matches.push({
       candidate,
       version: probe.version,
-      priority: getCodexCandidatePriority(candidate, env, repoRoot),
+      priority: getCodexCandidatePriority(candidate, env, repoRoot, platform),
     });
   }
 
@@ -229,12 +232,17 @@ function buildResolvedCodexBin({
   env: NodeJS.ProcessEnv;
   repoRoot: string;
 }): ResolvedCodexBin {
-  const normalized = String(value ?? "")
+  const normalizedValue = normalizeConfiguredCodexBin({
+    value,
+    env,
+    repoRoot,
+  });
+  const normalized = String(normalizedValue ?? "")
     .trim()
     .toLowerCase();
   if (normalized && normalized !== "codex") {
     return {
-      bin: value,
+      bin: normalizedValue,
       source,
       userConfigured: true,
     };
@@ -248,28 +256,79 @@ function buildResolvedCodexBin({
   };
 }
 
+export function normalizeConfiguredCodexBin({
+  value,
+  env = process.env,
+  repoRoot,
+  platform = process.platform,
+}: {
+  value: string;
+  env?: NodeJS.ProcessEnv;
+  repoRoot: string;
+  platform?: NodeJS.Platform;
+}): string {
+  const normalizedValue = String(value ?? "").trim();
+  if (!normalizedValue || platform !== "win32") {
+    return normalizedValue;
+  }
+
+  const normalizedBasename = path.win32.basename(normalizedValue).toLowerCase();
+  if (normalizedBasename !== "codex.cmd" && normalizedBasename !== "codex.bat") {
+    return normalizedValue;
+  }
+
+  if (path.win32.isAbsolute(normalizedValue)) {
+    const pathModule = selectPathModule(normalizedValue);
+    const wrapperDir = pathModule.dirname(normalizedValue);
+    const entrypoint = pathModule.join(
+      wrapperDir,
+      "node_modules",
+      "@openai",
+      "codex",
+      "bin",
+      "codex.js",
+    );
+    if (fs.existsSync(entrypoint)) {
+      return entrypoint;
+    }
+  }
+
+  return findWindowsNpmGlobalCodexBin(env, repoRoot, platform) || normalizedValue;
+}
+
 function findDetectedCodexBin(env: NodeJS.ProcessEnv, repoRoot: string): string {
   if (process.platform !== "win32") {
     return "";
   }
 
-  return findWindowsNpmGlobalCodexBin(env, repoRoot) || findVscodeCodexExe(env) || "";
+  return (
+    findWindowsNpmGlobalCodexBin(env, repoRoot, process.platform) || findVscodeCodexExe(env) || ""
+  );
 }
 
-function listCodexBinCandidates(env: NodeJS.ProcessEnv, repoRoot: string): string[] {
-  return dedupe(["codex", findWindowsNpmGlobalCodexBin(env, repoRoot), findVscodeCodexExe(env)]);
+function listCodexBinCandidates(
+  env: NodeJS.ProcessEnv,
+  repoRoot: string,
+  platform: NodeJS.Platform,
+): string[] {
+  return dedupe([
+    "codex",
+    findWindowsNpmGlobalCodexBin(env, repoRoot, platform),
+    findVscodeCodexExe(env),
+  ]);
 }
 
 function getCodexCandidatePriority(
   candidate: string,
   env: NodeJS.ProcessEnv,
   repoRoot: string,
+  platform: NodeJS.Platform,
 ): number {
   if (candidate === "codex") {
     return 0;
   }
 
-  const npmGlobal = findWindowsNpmGlobalCodexBin(env, repoRoot);
+  const npmGlobal = findWindowsNpmGlobalCodexBin(env, repoRoot, platform);
   if (npmGlobal && candidate === npmGlobal) {
     return 1;
   }
@@ -311,8 +370,12 @@ function findVscodeCodexExe(env: NodeJS.ProcessEnv): string {
   return "";
 }
 
-function findWindowsNpmGlobalCodexBin(env: NodeJS.ProcessEnv, repoRoot: string): string {
-  if (process.platform !== "win32") {
+function findWindowsNpmGlobalCodexBin(
+  env: NodeJS.ProcessEnv,
+  repoRoot: string,
+  platform: NodeJS.Platform,
+): string {
+  if (platform !== "win32") {
     return "";
   }
 
@@ -350,6 +413,14 @@ function findWindowsNpmGlobalCodexBin(env: NodeJS.ProcessEnv, repoRoot: string):
   return "";
 }
 
+function selectPathModule(filePath: string): typeof path.posix | typeof path.win32 {
+  const normalized = String(filePath ?? "").trim();
+  if (/^[A-Za-z]:[\\/]/.test(normalized) || normalized.includes("\\")) {
+    return path.win32;
+  }
+  return path.posix;
+}
+
 function readNpmPrefix(repoRoot: string): string {
   const result = spawnNpm(["config", "get", "prefix"], repoRoot);
   if (result.error || result.status !== 0) {
@@ -395,32 +466,11 @@ function runCodex({
 }
 
 function spawnCodex(codexBin: string, args: string[], repoRoot: string) {
-  if (/\.(cjs|mjs|js)$/i.test(codexBin)) {
-    return spawnSync(process.execPath, [codexBin, ...args], {
-      cwd: repoRoot,
-      stdio: ["ignore", "pipe", "pipe"],
-      shell: false,
-      encoding: "utf8",
-    });
-  }
-
-  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, {
+  return spawnCodexSync({
+    codexBin,
+    args,
     cwd: repoRoot,
     stdio: ["ignore", "pipe", "pipe"],
-    shell: false,
     encoding: "utf8",
   });
 }
@@ -493,10 +543,6 @@ function dedupe(values: Array<string | null | undefined>): string[] {
   return [...new Set(values.map((value) => String(value ?? "").trim()).filter(Boolean))];
 }
 
-function quoteWindowsShellValue(value: string): string {
-  return `"${String(value ?? "").replace(/"/g, '\\"')}"`;
-}
-
 function spawnNpm(args: string[], repoRoot: string) {
   if (process.platform === "win32") {
     const comspec = process.env.ComSpec || "cmd.exe";

package/scripts/src/codex-spawn.mts

@@ -0,0 +1,84 @@
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+
+type StdioMode = "pipe" | "inherit" | ["ignore", "pipe", "pipe"];
+
+type CodexSpawnSpec = {
+  command: string;
+  args: string[];
+  shell: boolean;
+};
+
+export function requiresNodeScriptCodexBin(command: string): boolean {
+  return /\.(cjs|mjs|js)$/i.test(String(command ?? "").trim());
+}
+
+export function requiresShellWrappedCodexBin(
+  command: string,
+  platform: NodeJS.Platform = process.platform,
+): boolean {
+  return platform === "win32" && /\.(cmd|bat)$/i.test(String(command ?? "").trim());
+}
+
+export function buildCodexSpawnSpec({
+  codexBin,
+  args,
+  platform = process.platform,
+  nodeBin = process.execPath,
+}: {
+  codexBin: string;
+  args: string[];
+  platform?: NodeJS.Platform;
+  nodeBin?: string;
+}): CodexSpawnSpec {
+  if (requiresNodeScriptCodexBin(codexBin)) {
+    return {
+      command: nodeBin,
+      args: [codexBin, ...args],
+      shell: false,
+    };
+  }
+
+  if (requiresShellWrappedCodexBin(codexBin, platform)) {
+    return {
+      command: [quoteWindowsShellValue(codexBin), ...args.map(quoteWindowsShellValue)].join(" "),
+      args: [],
+      shell: true,
+    };
+  }
+
+  return {
+    command: codexBin,
+    args: [...args],
+    shell: false,
+  };
+}
+
+export function spawnCodexSync({
+  codexBin,
+  args,
+  cwd,
+  stdio,
+  encoding = "utf8",
+  input,
+}: {
+  codexBin: string;
+  args: string[];
+  cwd: string;
+  stdio: StdioMode;
+  encoding?: BufferEncoding;
+  input?: string;
+}) {
+  const spec = buildCodexSpawnSpec({ codexBin, args });
+  return spawnSync(spec.command, spec.args, {
+    cwd,
+    stdio,
+    shell: spec.shell,
+    encoding,
+    ...(input !== undefined ? { input } : {}),
+  });
+}
+
+function quoteWindowsShellValue(value: string): string {
+  return `"${String(value ?? "").replace(/"/g, '\\"')}"`;
+}

package/scripts/test/codex-runtime.test.mjs

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { normalizeConfiguredCodexBin } from "../dist/codex-runtime.mjs";
+
+test("normalizeConfiguredCodexBin remaps absolute Windows npm wrappers to codex.js", () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "copilot-hub-codex-bin-"));
+  const wrapperDir = path.join(tempDir, "npm");
+  const packageDir = path.join(wrapperDir, "node_modules", "@openai", "codex", "bin");
+  fs.mkdirSync(packageDir, { recursive: true });
+
+  const wrapperPath = path.join(wrapperDir, "codex.cmd");
+  const entrypointPath = path.join(packageDir, "codex.js");
+  fs.writeFileSync(wrapperPath, "@echo off\r\n", "utf8");
+  fs.writeFileSync(entrypointPath, "console.log('ok');\n", "utf8");
+
+  const resolved = normalizeConfiguredCodexBin({
+    value: wrapperPath,
+    env: {},
+    repoRoot: tempDir,
+    platform: "win32",
+  });
+
+  assert.equal(resolved, entrypointPath);
+});
+
+test("normalizeConfiguredCodexBin resolves bare codex.cmd through detected npm install", () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "copilot-hub-codex-bin-"));
+  const appDataDir = path.join(tempDir, "AppData", "Roaming");
+  const packageDir = path.join(appDataDir, "npm", "node_modules", "@openai", "codex", "bin");
+  fs.mkdirSync(packageDir, { recursive: true });
+
+  const entrypointPath = path.join(packageDir, "codex.js");
+  fs.writeFileSync(entrypointPath, "console.log('ok');\n", "utf8");
+
+  const resolved = normalizeConfiguredCodexBin({
+    value: "codex.cmd",
+    env: {
+      APPDATA: appDataDir,
+    },
+    repoRoot: tempDir,
+    platform: "win32",
+  });
+
+  assert.equal(resolved, entrypointPath);
+});
+
+test("normalizeConfiguredCodexBin preserves non-wrapper commands", () => {
+  const resolved = normalizeConfiguredCodexBin({
+    value: "C:/tools/codex.exe",
+    env: {},
+    repoRoot: process.cwd(),
+    platform: "win32",
+  });
+
+  assert.equal(resolved, "C:/tools/codex.exe");
+});

package/scripts/test/codex-spawn.test.mjs

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import process from "node:process";
+import test from "node:test";
+import {
+  buildCodexSpawnSpec,
+  requiresNodeScriptCodexBin,
+  requiresShellWrappedCodexBin,
+} from "../dist/codex-spawn.mjs";
+
+test("requiresNodeScriptCodexBin matches js entrypoints only", () => {
+  assert.equal(requiresNodeScriptCodexBin("C:/tools/codex.js"), true);
+  assert.equal(requiresNodeScriptCodexBin("C:/tools/codex.mjs"), true);
+  assert.equal(requiresNodeScriptCodexBin("C:/tools/codex.cjs"), true);
+  assert.equal(requiresNodeScriptCodexBin("C:/tools/codex.exe"), false);
+  assert.equal(requiresNodeScriptCodexBin("C:/tools/codex.cmd"), false);
+});
+
+test("requiresShellWrappedCodexBin matches Windows batch launchers only", () => {
+  assert.equal(requiresShellWrappedCodexBin("C:/tools/codex.cmd", "win32"), true);
+  assert.equal(requiresShellWrappedCodexBin("C:/tools/codex.bat", "win32"), true);
+  assert.equal(requiresShellWrappedCodexBin("C:/tools/codex.exe", "win32"), false);
+  assert.equal(requiresShellWrappedCodexBin("C:/tools/codex.js", "win32"), false);
+});
+
+test("buildCodexSpawnSpec routes js entrypoints through node", () => {
+  const spec = buildCodexSpawnSpec({
+    codexBin: "C:/Users/amine/AppData/Roaming/npm/node_modules/@openai/codex/bin/codex.js",
+    args: ["login", "status"],
+    platform: "win32",
+    nodeBin: process.execPath,
+  });
+
+  assert.equal(spec.command, process.execPath);
+  assert.deepEqual(spec.args, [
+    "C:/Users/amine/AppData/Roaming/npm/node_modules/@openai/codex/bin/codex.js",
+    "login",
+    "status",
+  ]);
+  assert.equal(spec.shell, false);
+});
+
+test("buildCodexSpawnSpec keeps exe direct and cmd shell-wrapped", () => {
+  const exeSpec = buildCodexSpawnSpec({
+    codexBin: "C:/tools/codex.exe",
+    args: ["--version"],
+    platform: "win32",
+  });
+  assert.equal(exeSpec.command, "C:/tools/codex.exe");
+  assert.deepEqual(exeSpec.args, ["--version"]);
+  assert.equal(exeSpec.shell, false);
+
+  const cmdSpec = buildCodexSpawnSpec({
+    codexBin: "C:/tools/codex.cmd",
+    args: ["login", "status"],
+    platform: "win32",
+  });
+  assert.equal(cmdSpec.shell, true);
+  assert.equal(cmdSpec.args.length, 0);
+  assert.match(cmdSpec.command, /^"C:\/tools\/codex\.cmd" "login" "status"$/);
+});