@christiandoxa/prodex 0.212.0 → 0.214.0

package/README.md

@@ -127,7 +127,7 @@ Runtime proxy design contract:
 npm install -g @christiandoxa/prodex
 ```
 
-The npm package uses its bundled `@openai/codex@latest` dependency by default. To deliberately use a separate Codex CLI from your machine, set `PRODEX_CODEX_BIN=/path/to/codex` or `PRODEX_CODEX_RESOLUTION=external`.
+The npm package uses its bundled `@openai/codex@latest` dependency by default. If the bundled native Codex optional package is missing or not executable, Prodex falls back to an executable external `codex` on `PATH` and prints a notice before launch. This includes nvm-managed global Codex installs when the active nvm version's `bin` directory is on `PATH`. If neither bundled nor external Codex is usable, set `PRODEX_CODEX_AUTO_INSTALL=1` to let Prodex run `npm install -g @openai/codex@latest` once before retrying PATH resolution. To deliberately pin a separate Codex CLI from your machine, set `PRODEX_CODEX_BIN=/path/to/codex` or `PRODEX_CODEX_RESOLUTION=external`.
 
 </details>
 
@@ -898,6 +898,7 @@ prodex run --rollout-budget-tokens 100000 --rollout-budget-reminders 75000,50000
 
 prodex run --current-time-reminder
 prodex run --current-time-reminder --current-time-reminder-interval 2
+prodex run --respect-system-proxy
 ```
 
 `--web-search` maps to Codex's top-level `web_search = "disabled" | "cached" | "indexed" | "live"` setting. In Super provider mode, an explicit `--web-search` is appended after the provider default, so it overrides the default bridge choice.
@@ -906,6 +907,8 @@ prodex run --current-time-reminder --current-time-reminder-interval 2
 
 `--current-time-reminder` enables Codex's `[features.current_time_reminder]` config. The default system clock source is owned by Codex. `--current-time-clock-source external` is intended for Codex app-server clients that implement the upstream `currentTime/read` request.
 
+`--respect-system-proxy` enables Codex's `[features.respect_system_proxy]` config when the bundled/upstream Codex supports it. Codex 0.142.1 uses this opt-in feature for Windows auth clients so PAC, WPAD, static system proxy, and bypass decisions can be honored. `--no-respect-system-proxy` renders an explicit false override for sessions that need the upstream default direct/env-proxy behavior.
+
 Codex `multiAgentMode` is an app-server/thread setting, not a normal TUI `config.toml` launch override. Prodex therefore does not invent a competing CLI config flag. Launch `prodex app-server` or `prodex run app-server` and pass upstream `multiAgentMode` values (`none`, `explicitRequestOnly`, or `proactive`) through the Codex app-server API.
 
 Codex plugin catalog commands are managed passthrough by default:

package/lib/codex-shim.cjs

@@ -3,7 +3,7 @@
 
 const fs = require("node:fs");
 const path = require("node:path");
-const { spawn } = require("node:child_process");
+const { spawn, spawnSync } = require("node:child_process");
 const { createRequire } = require("node:module");
 
 const requireFromHere = createRequire(__filename);
@@ -47,169 +47,370 @@ const PLATFORM_TARGETS = {
   },
 };
 
-function currentPlatformTarget() {
-  return PLATFORM_TARGETS[process.platform]?.[process.arch] ?? null;
+function platformSpec() {
+  return PLATFORM_TARGETS[process.platform]?.[process.arch] || null;
 }
 
-function resolveOpenAiCodexPackageRoot() {
-  let packageJsonPath;
+function isExecutableFile(filePath) {
   try {
-    packageJsonPath = requireFromHere.resolve("@openai/codex/package.json");
+    const stats = fs.statSync(filePath);
+    if (!stats.isFile()) {
+      return false;
+    }
+    fs.accessSync(filePath, fs.constants.X_OK);
+    return true;
   } catch {
-    return null;
+    return false;
   }
-  return path.dirname(packageJsonPath);
 }
 
-function codexManagedEnv() {
-  const packageRoot = resolveOpenAiCodexPackageRoot();
-  if (!packageRoot) {
-    return process.env;
+function tryMakeExecutable(filePath) {
+  if (process.platform === "win32") {
+    return;
+  }
+  try {
+    const stats = fs.statSync(filePath);
+    if (stats.isFile()) {
+      fs.chmodSync(filePath, (stats.mode & 0o777) | 0o755);
+    }
+  } catch {
+    // The explicit executable check below reports the actionable failure.
   }
-  return {
-    ...process.env,
-    CODEX_MANAGED_BY_NPM: "1",
-    CODEX_MANAGED_PACKAGE_ROOT: fs.realpathSync(packageRoot),
-  };
 }
 
-function ensureNativeCodexExecutable(nativeBinaryPath) {
+function managedCodexPackageRoot(fallbackRoot) {
   try {
-    fs.accessSync(nativeBinaryPath, fs.constants.X_OK);
-    return;
+    return fs.realpathSync(path.dirname(requireFromHere.resolve("@openai/codex/package.json")));
   } catch {
-    repairNativeCodexExecutablePermissionBestEffort(nativeBinaryPath);
+    return fs.realpathSync(fallbackRoot);
   }
+}
+
+function nativePackagePaths(spec) {
+  const packageJsonPath = requireFromHere.resolve(`${spec.packageName}/package.json`);
+  const packageRoot = path.dirname(packageJsonPath);
+  return {
+    packageRoot,
+    managedPackageRoot: managedCodexPackageRoot(packageRoot),
+    binaryPath: path.join(
+      packageRoot,
+      "vendor",
+      spec.targetTriple,
+      "bin",
+      spec.binaryFileName,
+    ),
+  };
+}
 
+function resolveNativeCodexCommand() {
+  const spec = platformSpec();
+  if (!spec) {
+    return {
+      ok: false,
+      reason: `Unsupported Codex platform ${process.platform}/${process.arch}.`,
+    };
+  }
+
+  let binaryPath;
+  let packageRoot;
+  let managedPackageRoot;
   try {
-    fs.accessSync(nativeBinaryPath, fs.constants.X_OK);
-    return;
-  } catch {
-    process.stderr.write(
-      [
-        `Bundled Codex native binary is not executable: ${nativeBinaryPath}`,
-        "Reinstall @christiandoxa/prodex with optional dependencies enabled, or set PRODEX_CODEX_BIN to an existing Codex CLI.",
-        "",
+    ({ binaryPath, packageRoot, managedPackageRoot } = nativePackagePaths(spec));
+  } catch (error) {
+    return {
+      ok: false,
+      reason: [
+        "Unable to locate bundled Codex native package for this platform.",
+        `Missing bundled Codex native package ${spec.packageName}.`,
+        `Original error: ${error && error.message ? error.message : String(error)}`,
       ].join("\n"),
-    );
-    process.exit(126);
+    };
   }
+
+  tryMakeExecutable(binaryPath);
+
+  if (!isExecutableFile(binaryPath)) {
+    return {
+      ok: false,
+      reason: `Bundled Codex native binary is not executable: ${binaryPath}`,
+      binaryPath,
+    };
+  }
+
+  return {
+    ok: true,
+    command: binaryPath,
+    args: process.argv.slice(2),
+    env: {
+      CODEX_MANAGED_BY_NPM: "1",
+      CODEX_MANAGED_PACKAGE_ROOT: managedPackageRoot,
+    },
+  };
 }
 
-function repairNativeCodexExecutablePermissionBestEffort(nativeBinaryPath) {
-  if (process.platform === "win32") {
-    return;
+function pathEntries() {
+  return (process.env.PATH || "")
+    .split(path.delimiter)
+    .filter((entry) => entry.length > 0);
+}
+
+function commandNames(command) {
+  if (process.platform !== "win32") {
+    return [command];
+  }
+  const pathext = (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM")
+    .split(";")
+    .filter(Boolean);
+  const lower = command.toLowerCase();
+  if (pathext.some((ext) => lower.endsWith(ext.toLowerCase()))) {
+    return [command];
   }
+  return [command, ...pathext.map((ext) => `${command}${ext}`)];
+}
+
+function isSelfShim(candidate) {
   try {
-    const stats = fs.statSync(nativeBinaryPath);
-    if (!stats.isFile()) {
-      return;
+    if (fs.realpathSync(candidate) === fs.realpathSync(__filename)) {
+      return true;
     }
-    fs.chmodSync(nativeBinaryPath, (stats.mode & 0o777) | 0o755);
   } catch {
-    // The explicit executable check below reports the actionable failure.
+    // Continue with the lightweight content check.
   }
-}
-
-function resolveNativeCodexCommand() {
-  const platformTarget = currentPlatformTarget();
-  if (!platformTarget) {
-    return null;
+  try {
+    const prefix = fs.readFileSync(candidate, "utf8").slice(0, 4096);
+    return prefix.includes(__filename);
+  } catch {
+    return false;
   }
+}
 
-  let platformPackageJsonPath;
+function candidateKey(candidate) {
   try {
-    platformPackageJsonPath = requireFromHere.resolve(`${platformTarget.packageName}/package.json`);
+    return fs.realpathSync(candidate).toLowerCase();
   } catch {
-    return null;
+    return path.resolve(candidate).toLowerCase();
   }
+}
 
-  const nativeBinaryPath = path.join(
-    path.dirname(platformPackageJsonPath),
-    "vendor",
-    platformTarget.targetTriple,
-    "bin",
-    platformTarget.binaryFileName,
-  );
-  if (!fs.existsSync(nativeBinaryPath)) {
-    process.stderr.write(
-      [
-        `Missing bundled Codex native binary at ${nativeBinaryPath}`,
-        "Reinstall @christiandoxa/prodex with optional dependencies enabled, or set PRODEX_CODEX_BIN to an existing Codex CLI.",
-        "",
-      ].join("\n"),
-    );
-    process.exit(1);
+function externalCodexCandidates() {
+  const seen = new Set();
+  const candidates = [];
+  for (const dir of pathEntries()) {
+    for (const name of commandNames("codex")) {
+      const candidate = path.join(dir, name);
+      const key = candidateKey(candidate);
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      candidates.push(candidate);
+    }
   }
-  ensureNativeCodexExecutable(nativeBinaryPath);
+  return candidates;
+}
+
+function summarizeSkippedExternalCandidates(skipped) {
+  if (skipped.length === 0) {
+    return "No codex candidates were found on PATH.";
+  }
+  const shown = skipped.slice(0, 8).map(({ candidate, reason }) => `- ${candidate} (${reason})`);
+  if (skipped.length > shown.length) {
+    shown.push(`- ... ${skipped.length - shown.length} more skipped candidates`);
+  }
+  return ["Searched PATH for external codex candidates:", ...shown].join("\n");
+}
 
+function resolveExternalCodexCommand() {
+  const skipped = [];
+  for (const candidate of externalCodexCandidates()) {
+    if (isSelfShim(candidate)) {
+      skipped.push({ candidate, reason: "Prodex Codex shim" });
+      continue;
+    }
+    if (!isExecutableFile(candidate)) {
+      skipped.push({ candidate, reason: "not executable" });
+      continue;
+    }
+    return {
+      ok: true,
+      command: candidate,
+      args: process.argv.slice(2),
+      searched: skipped,
+    };
+  }
   return {
-    command: nativeBinaryPath,
-    args: process.argv.slice(2),
-    env: codexManagedEnv(),
+    ok: false,
+    reason: [
+      "No executable external codex was found on PATH.",
+      summarizeSkippedExternalCandidates(skipped),
+    ].join("\n"),
+    searched: skipped,
   };
 }
 
-function resolveCodexJsCommand() {
-  const packageRoot = resolveOpenAiCodexPackageRoot();
-  if (!packageRoot) {
-    process.stderr.write(
-      "Unable to locate @openai/codex. Reinstall @christiandoxa/prodex so its runtime dependency is present.\n",
-    );
-    process.exit(1);
+
+function autoInstallCodexEnabled() {
+  return ["1", "true", "yes"].includes(
+    (process.env.PRODEX_CODEX_AUTO_INSTALL || "").toLowerCase(),
+  );
+}
+
+function npmCommandNames() {
+  return commandNames("npm");
+}
+
+function resolveNpmCommand() {
+  const skipped = [];
+  for (const dir of pathEntries()) {
+    for (const name of npmCommandNames()) {
+      const candidate = path.join(dir, name);
+      if (!isExecutableFile(candidate)) {
+        skipped.push({ candidate, reason: "not executable" });
+        continue;
+      }
+      return { ok: true, command: candidate, searched: skipped };
+    }
+  }
+  return { ok: false, reason: "No executable npm was found on PATH.", searched: skipped };
+}
+
+function installExternalCodexWithNpm() {
+  if (!autoInstallCodexEnabled()) {
+    return { ok: false, reason: "PRODEX_CODEX_AUTO_INSTALL is not enabled." };
   }
-  const packageJsonPath = path.join(packageRoot, "package.json");
 
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-  if (typeof packageJson.bin === "string") {
+  const npmCommand = resolveNpmCommand();
+  if (!npmCommand.ok) {
+    return npmCommand;
+  }
+
+  process.stderr.write(
+    [
+      "No executable external codex was found; attempting npm install because PRODEX_CODEX_AUTO_INSTALL=1.",
+      "Running: npm install -g @openai/codex@latest",
+      "",
+    ].join("\n"),
+  );
+
+  const result = spawnSync(npmCommand.command, ["install", "-g", "@openai/codex@latest"], {
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  if (result.error) {
     return {
-      command: process.execPath,
-      args: [path.resolve(packageRoot, packageJson.bin), ...process.argv.slice(2)],
-      env: process.env,
+      ok: false,
+      reason: `npm install failed to start: ${result.error.message}`,
     };
   }
-  if (packageJson.bin && typeof packageJson.bin === "object") {
-    const candidate = packageJson.bin.codex ?? Object.values(packageJson.bin)[0];
-    if (typeof candidate === "string") {
-      return {
-        command: process.execPath,
-        args: [path.resolve(packageRoot, candidate), ...process.argv.slice(2)],
-        env: process.env,
-      };
-    }
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      reason: `npm install exited with status ${result.status}`,
+    };
   }
-  return {
-    command: process.execPath,
-    args: [path.resolve(packageRoot, "bin", "codex.js"), ...process.argv.slice(2)],
-    env: process.env,
-  };
+
+  return resolveExternalCodexCommand();
 }
 
 function resolveCodexCommand() {
-  return resolveNativeCodexCommand() ?? resolveCodexJsCommand();
-}
+  const nativeCommand = resolveNativeCodexCommand();
+  if (nativeCommand.ok) {
+    return nativeCommand;
+  }
 
-const codexCommand = resolveCodexCommand();
-const child = spawn(codexCommand.command, codexCommand.args, {
-  env: codexCommand.env,
-  stdio: "inherit",
-});
+  let externalCommand = resolveExternalCodexCommand();
+  if (!externalCommand.ok && autoInstallCodexEnabled()) {
+    const installCommand = installExternalCodexWithNpm();
+    if (installCommand.ok) {
+      externalCommand = installCommand;
+    } else {
+      externalCommand = {
+        ...externalCommand,
+        reason: [externalCommand.reason, installCommand.reason].filter(Boolean).join("\n"),
+      };
+    }
+  }
 
-child.on("error", (error) => {
-  if (error && error.code === "EACCES") {
+  if (externalCommand.ok) {
     process.stderr.write(
-      `${error.message}\nSet PRODEX_CODEX_BIN to an existing Codex CLI or reinstall @christiandoxa/prodex.\n`,
+      [
+        "Bundled Codex is unavailable; falling back to external codex from PATH.",
+        nativeCommand.reason,
+        summarizeSkippedExternalCandidates(externalCommand.searched || []),
+        `External codex: ${externalCommand.command}`,
+        "Set PRODEX_CODEX_BIN to pin a specific Codex executable.",
+        "",
+      ].join("\n"),
     );
-  } else {
-    process.stderr.write(`${error.message}\n`);
+    return externalCommand;
   }
+
+  process.stderr.write(
+    [
+      nativeCommand.reason || "Unable to locate bundled Codex native package for this platform.",
+      "Reinstall @christiandoxa/prodex with optional dependencies enabled, set PRODEX_CODEX_BIN to an existing Codex CLI, or set PRODEX_CODEX_AUTO_INSTALL=1 to let Prodex run npm install -g @openai/codex@latest.",
+      "Prodex does not fall back to @openai/codex/bin/codex.js because npm/Node version skew can make Codex load the wrong optional native package.",
+      externalCommand.reason,
+      "",
+    ].join("\n"),
+  );
   process.exit(1);
-});
+}
 
-child.on("exit", (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
-    return;
-  }
-  process.exit(code ?? 1);
-});
+function spawnCodex(codexCommand, retriedExternalFallback = false) {
+  const child = spawn(codexCommand.command, codexCommand.args, {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ...(codexCommand.env || {}),
+    },
+  });
+
+  child.on("error", (error) => {
+    if (error && error.code === "EACCES" && !retriedExternalFallback) {
+      let externalCommand = resolveExternalCodexCommand();
+      if (!externalCommand.ok && autoInstallCodexEnabled()) {
+        const installCommand = installExternalCodexWithNpm();
+        if (installCommand.ok) {
+          externalCommand = installCommand;
+        }
+      }
+      if (externalCommand.ok && externalCommand.command !== codexCommand.command) {
+        process.stderr.write(
+          [
+            `${error.message}`,
+            "Bundled Codex could not be executed; falling back to external codex from PATH.",
+            summarizeSkippedExternalCandidates(externalCommand.searched || []),
+            `External codex: ${externalCommand.command}`,
+            "Set PRODEX_CODEX_BIN to pin a specific Codex executable.",
+            "",
+          ].join("\n"),
+        );
+        spawnCodex(externalCommand, true);
+        return;
+      }
+    }
+
+    if (error && error.code === "EACCES") {
+      process.stderr.write(
+        `${error.message}\nSet PRODEX_CODEX_BIN to an existing Codex CLI, set PRODEX_CODEX_AUTO_INSTALL=1 to let Prodex run npm install -g @openai/codex@latest, or reinstall @christiandoxa/prodex.\n`,
+      );
+      process.exit(126);
+      return;
+    }
+
+    process.stderr.write(`${error && error.message ? error.message : String(error)}\n`);
+    process.exit(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 1);
+  });
+}
+
+spawnCodex(resolveCodexCommand());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@christiandoxa/prodex",
-  "version": "0.212.0",
+  "version": "0.214.0",
   "description": "Multi-provider Codex wrapper with OpenAI quota-aware routing and Claude Code support",
   "license": "Apache-2.0",
   "bin": {
@@ -16,12 +16,12 @@
     "@openai/codex": "latest"
   },
   "optionalDependencies": {
-    "@christiandoxa/prodex-linux-x64": "0.212.0",
-    "@christiandoxa/prodex-linux-arm64": "0.212.0",
-    "@christiandoxa/prodex-darwin-x64": "0.212.0",
-    "@christiandoxa/prodex-darwin-arm64": "0.212.0",
-    "@christiandoxa/prodex-win32-x64": "0.212.0",
-    "@christiandoxa/prodex-win32-arm64": "0.212.0",
+    "@christiandoxa/prodex-linux-x64": "0.214.0",
+    "@christiandoxa/prodex-linux-arm64": "0.214.0",
+    "@christiandoxa/prodex-darwin-x64": "0.214.0",
+    "@christiandoxa/prodex-darwin-arm64": "0.214.0",
+    "@christiandoxa/prodex-win32-x64": "0.214.0",
+    "@christiandoxa/prodex-win32-arm64": "0.214.0",
     "@openai/codex-linux-x64": "npm:@openai/codex@linux-x64",
     "@openai/codex-linux-arm64": "npm:@openai/codex@linux-arm64",
     "@openai/codex-darwin-x64": "npm:@openai/codex@darwin-x64",