@christiandoxa/prodex 0.213.0 → 0.215.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:
@@ -972,7 +975,7 @@ prodex s
 prodex s exec "review this repo"
 ANTHROPIC_API_KEY=... prodex s --provider anthropic --model claude-sonnet-4-6
 prodex profile import copilot
-prodex s --provider copilot --model gpt-5.1-codex
+prodex s --provider copilot --model gpt-5.3-codex
 DEEPSEEK_API_KEY=... prodex s deepseek --model deepseek-v4-pro
 prodex s gemini
 prodex super
@@ -1004,7 +1007,7 @@ Use `--provider copilot` when you want the Codex/Super front end with GitHub Cop
 
 ```bash
 prodex profile import copilot
-prodex s --provider copilot --model gpt-5.1-codex
+prodex s --provider copilot --model gpt-5.3-codex
 ```
 
 Without `--api-key`, Prodex uses imported Copilot CLI profiles, refreshes Copilot runtime API tokens from GitHub before launch, can rotate fresh native Responses requests across multiple eligible profiles, and binds streaming response IDs back to the owning profile for continuations. `GITHUB_COPILOT_API_KEY`, `GITHUB_COPILOT_API_KEYS`, or `--api-key` can be used when you already have Copilot runtime API token(s); plural keys may be comma-, semicolon-, or newline-separated and can rotate before commit on auth/quota/rate/temporary failures.

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,147 +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);
+    }
+  }
+  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`);
   }
-  ensureNativeCodexExecutable(nativeBinaryPath);
+  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 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 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 {
+      ok: false,
+      reason: `npm install failed to start: ${result.error.message}`,
+    };
+  }
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      reason: `npm install exited with status ${result.status}`,
+    };
+  }
+
+  return resolveExternalCodexCommand();
+}
+
 function resolveCodexCommand() {
   const nativeCommand = resolveNativeCodexCommand();
-  if (nativeCommand) {
+  if (nativeCommand.ok) {
     return nativeCommand;
   }
 
+  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"),
+      };
+    }
+  }
+
+  if (externalCommand.ok) {
+    process.stderr.write(
+      [
+        "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"),
+    );
+    return externalCommand;
+  }
+
   process.stderr.write(
     [
-      "Unable to locate bundled Codex native package for this platform.",
-      "Reinstall @christiandoxa/prodex with optional dependencies enabled, or set PRODEX_CODEX_BIN to an existing Codex CLI.",
+      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);
 }
 
-const codexCommand = resolveCodexCommand();
-const child = spawn(codexCommand.command, codexCommand.args, {
-  env: codexCommand.env,
-  stdio: "inherit",
-});
+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") {
-    process.stderr.write(
-      `${error.message}\nSet PRODEX_CODEX_BIN to an existing Codex CLI or reinstall @christiandoxa/prodex.\n`,
-    );
-  } else {
-    process.stderr.write(`${error.message}\n`);
-  }
-  process.exit(1);
-});
+  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;
+      }
+    }
 
-child.on("exit", (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
-    return;
-  }
-  process.exit(code ?? 1);
-});
+    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.213.0",
+  "version": "0.215.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.213.0",
-    "@christiandoxa/prodex-linux-arm64": "0.213.0",
-    "@christiandoxa/prodex-darwin-x64": "0.213.0",
-    "@christiandoxa/prodex-darwin-arm64": "0.213.0",
-    "@christiandoxa/prodex-win32-x64": "0.213.0",
-    "@christiandoxa/prodex-win32-arm64": "0.213.0",
+    "@christiandoxa/prodex-linux-x64": "0.215.0",
+    "@christiandoxa/prodex-linux-arm64": "0.215.0",
+    "@christiandoxa/prodex-darwin-x64": "0.215.0",
+    "@christiandoxa/prodex-darwin-arm64": "0.215.0",
+    "@christiandoxa/prodex-win32-x64": "0.215.0",
+    "@christiandoxa/prodex-win32-arm64": "0.215.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",