codex-multi-auth 1.3.2 → 2.0.1

package/scripts/bench-format/codex-host.mjs

@@ -1,20 +1,39 @@
-import { spawnSync } from "node:child_process";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
 const scriptDir = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(scriptDir, "..", "..");
 
-export function getRepoRoot() {
-  return repoRoot;
-}
-
-export function resolveCodexExecutable() {
-  const envOverride = process.env.CODEX_BIN;
-  if (envOverride && envOverride.trim().length > 0) {
-    const command = envOverride.trim();
-    return { command, shell: /\.cmd$/i.test(command) };
-  }
+export function getRepoRoot() {
+  return repoRoot;
+}
+
+function resolveWindowsNpmShim(command) {
+  if (!/\.(cmd|bat)$/i.test(command)) {
+    return { command, shell: false };
+  }
+
+  const codexScript = join(dirname(command), "node_modules", "codex-multi-auth", "scripts", "codex.js");
+  if (existsSync(codexScript)) {
+    return {
+      command: process.execPath,
+      shell: false,
+      argsPrefix: [codexScript],
+      shimCommand: command,
+    };
+  }
+
+  return { command, shell: true };
+}
+
+export function resolveCodexExecutable() {
+  const envOverride = process.env.CODEX_BIN;
+  if (envOverride && envOverride.trim().length > 0) {
+    const command = envOverride.trim();
+    return process.platform === "win32" ? resolveWindowsNpmShim(command) : { command, shell: false };
+  }
 
   if (process.platform !== "win32") {
     return { command: "codex", shell: false };
@@ -38,15 +57,15 @@ export function resolveCodexExecutable() {
     return { command: exactExe, shell: false };
   }
 
-  const exactCmd = candidates.find((candidate) => /npm\\Codex\.cmd$/i.test(candidate));
-  if (exactCmd) {
-    return { command: exactCmd, shell: true };
-  }
-
-  const anyCmd = candidates.find((candidate) => /\.cmd$/i.test(candidate));
-  if (anyCmd) {
-    return { command: anyCmd, shell: true };
-  }
+  const exactCmd = candidates.find((candidate) => /npm\\Codex\.cmd$/i.test(candidate));
+  if (exactCmd) {
+    return resolveWindowsNpmShim(exactCmd);
+  }
+
+  const anyCmd = candidates.find((candidate) => /\.cmd$/i.test(candidate));
+  if (anyCmd) {
+    return resolveWindowsNpmShim(anyCmd);
+  }
 
   return { command: candidates[0], shell: false };
 }
@@ -67,23 +86,35 @@ export function parseNdjson(text) {
   return events;
 }
 
-export function getToolEvents(events) {
-  return events
-    .filter((event) => event?.type === "tool_use" && event?.part?.type === "tool")
-    .map((event) => ({
-      tool: event.part.tool,
-      input: event.part.state?.input ?? {},
-      output: event.part.state?.output,
+export function getToolEvents(events) {
+  const legacyToolEvents = events
+    .filter((event) => event?.type === "tool_use" && event?.part?.type === "tool")
+    .map((event) => ({
+      tool: event.part.tool,
+      input: event.part.state?.input ?? {},
+      output: event.part.state?.output,
       status: event.part.state?.status,
       start: event.part.state?.time?.start,
       end: event.part.state?.time?.end,
       durationMs:
         typeof event.part.state?.time?.start === "number" &&
         typeof event.part.state?.time?.end === "number"
-          ? event.part.state.time.end - event.part.state.time.start
-          : null,
-    }));
-}
+          ? event.part.state.time.end - event.part.state.time.start
+          : null,
+    }));
+  const execToolEvents = events
+    .filter((event) => event?.type === "item.completed" && event?.item?.type === "command_execution")
+    .map((event) => ({
+      tool: "command_execution",
+      input: { command: event.item.command },
+      output: event.item.aggregated_output,
+      status: event.item.status,
+      start: null,
+      end: null,
+      durationMs: null,
+    }));
+  return [...legacyToolEvents, ...execToolEvents];
+}
 
 export function getSessionDuration(events) {
   const starts = events
@@ -98,11 +129,12 @@ export function getSessionDuration(events) {
   return Math.max(...finishes) - Math.min(...starts);
 }
 
-export function getTokenTotals(events) {
-  const stepFinishes = events.filter((event) => event?.type === "step_finish" && event?.part?.tokens);
-  if (stepFinishes.length === 0) {
-    return null;
-  }
+export function getTokenTotals(events) {
+  const stepFinishes = events.filter((event) => event?.type === "step_finish" && event?.part?.tokens);
+  const turnCompletions = events.filter((event) => event?.type === "turn.completed" && event?.usage);
+  if (stepFinishes.length === 0 && turnCompletions.length === 0) {
+    return null;
+  }
   const total = {
     total: 0,
     input: 0,
@@ -121,29 +153,49 @@ export function getTokenTotals(events) {
     total.input += input;
     total.output += output;
     total.reasoning += reasoning;
-    total.cacheRead += Number(tokens.cache?.read ?? 0);
-    total.cacheWrite += Number(tokens.cache?.write ?? 0);
-  }
-  return total;
-}
+    total.cacheRead += Number(tokens.cache?.read ?? 0);
+    total.cacheWrite += Number(tokens.cache?.write ?? 0);
+  }
+  for (const event of turnCompletions) {
+    const usage = event.usage ?? {};
+    const input = Number(usage.input_tokens ?? 0);
+    const output = Number(usage.output_tokens ?? 0);
+    const reasoning = Number(usage.reasoning_output_tokens ?? 0);
+    total.total += input + output;
+    total.input += input;
+    total.output += output;
+    total.reasoning += reasoning;
+    total.cacheRead += Number(usage.cached_input_tokens ?? 0);
+  }
+  return total;
+}
 
-export function getTextOutput(events) {
-  return events
-    .filter((event) => event?.type === "text" && typeof event?.part?.text === "string")
-    .map((event) => event.part.text)
-    .join("\n");
-}
-
-export function getEventError(events) {
-  const errorEvent = events.find((event) => event?.type === "error");
-  if (!errorEvent) {
-    return null;
-  }
-  return {
-    name: errorEvent.error?.name ?? "UnknownError",
-    message: errorEvent.error?.data?.message ?? errorEvent.error?.message ?? "Unknown error",
-  };
-}
+export function getTextOutput(events) {
+  const legacyText = events
+    .filter((event) => event?.type === "text" && typeof event?.part?.text === "string")
+    .map((event) => event.part.text)
+    .join("\n");
+  const execText = events
+    .filter((event) => event?.type === "item.completed" && event?.item?.type === "agent_message" && typeof event.item.text === "string")
+    .map((event) => event.item.text)
+    .join("\n");
+  return [legacyText, execText].filter(Boolean).join("\n");
+}
+
+export function getEventError(events) {
+  const lastCompletedIndex = events.findLastIndex((event) => event?.type === "turn.completed");
+  const failureIndex = events.findLastIndex(
+    (event, index) => index > lastCompletedIndex && (event?.type === "error" || event?.type === "turn.failed"),
+  );
+  if (failureIndex < 0) {
+    return null;
+  }
+  const errorEvent = events[failureIndex];
+  return {
+    name: errorEvent.error?.name ?? errorEvent.type ?? "UnknownError",
+    message: errorEvent.error?.data?.message ?? errorEvent.error?.message ?? errorEvent.message ?? "Unknown error",
+  };
+}
 
 export function runCodexJson({
   executable,
@@ -155,20 +207,33 @@ export function runCodexJson({
   homeDir,
   timeoutMs,
   extraEnv,
-}) {
-  const startWall = Date.now();
-  const args = ["run", "--format", "json", "--agent", agent, "--model", model];
-  if (variant) {
-    args.push("--variant", variant);
-  }
-  args.push(prompt);
-
-  const child = spawnSync(executable.command, args, {
+}) {
+  const startWall = Date.now();
+  const args = [
+    "exec",
+    "--json",
+    "--model",
+    model,
+    "--skip-git-repo-check",
+    "--sandbox",
+    "danger-full-access",
+    "-c",
+    "approval_policy='never'",
+  ];
+  if (variant) {
+    args.push("-c", `model_reasoning_effort='${variant}'`);
+  }
+  void agent;
+  args.push(prompt);
+  const childArgs = [...(executable.argsPrefix ?? []), ...args];
+
+  const child = spawnSync(executable.command, childArgs, {
     cwd: cwd ?? repoRoot,
     encoding: "utf8",
-    windowsHide: true,
-    shell: executable.shell,
-    timeout: timeoutMs,
+    windowsHide: true,
+    shell: executable.shell,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: timeoutMs,
     maxBuffer: 30 * 1024 * 1024,
     env: {
       ...process.env,
@@ -189,7 +254,11 @@ export function runCodexJson({
   if (child.error && !timedOut) {
     throw child.error;
   }
-  const modelNotFound = /Model not found|ProviderModelNotFoundError/i.test(`${stdout}\n${stderr}`) || /Model not found/i.test(eventError?.message ?? "");
+  const failed = (child.status ?? 1) !== 0 || eventError !== null;
+  const modelNotFound =
+    failed &&
+    (/Model not found|ProviderModelNotFoundError|model is not supported|not supported when using Codex/i.test(`${stdout}\n${stderr}`) ||
+      /Model not found|model is not supported|not supported when using Codex/i.test(eventError?.message ?? ""));
 
   return {
     status: child.status ?? 1,

package/scripts/bench-format/models.mjs

@@ -1,14 +1,12 @@
 import { spawnSync } from "node:child_process";
 import { resolveCodexExecutable } from "./codex-host.mjs";
 
-const FALLBACK_OPENAI_CODEX_STABLE = [
-  "openai/gpt-5-codex",
-  "openai/gpt-5.1-codex",
-  "openai/gpt-5.1-codex-mini",
-  "openai/gpt-5.1-codex-max",
-  "openai/gpt-5.2-codex",
-  "openai/gpt-5.3-codex",
-];
+const FALLBACK_OPENAI_CODEX_STABLE = [
+  "openai/gpt-5.3-codex",
+  "openai/gpt-5.4",
+  "openai/gpt-5.4-mini",
+  "openai/gpt-5.5",
+];
 
 const OPENAI_CODEX_PREFIXES = ["openai/", "openai-multi/"];
 
@@ -25,14 +23,14 @@ export function canonicalCodexModelId(modelId) {
   return `openai/${codexTail(modelId)}`;
 }
 
-export function aliasCandidatesForCodexModel(modelId) {
-  if (!isOpenAiCodexProviderPrefix(modelId)) {
-    return [modelId];
-  }
-  const tail = codexTail(modelId);
-  const candidates = [`openai/${tail}`, `openai-multi/${tail}`];
-  return [...new Set([modelId, ...candidates])];
-}
+export function aliasCandidatesForCodexModel(modelId) {
+  if (!isOpenAiCodexProviderPrefix(modelId)) {
+    return [modelId];
+  }
+  const tail = codexTail(modelId);
+  const candidates = [`openai/${tail}`, `openai-multi/${tail}`];
+  return [...new Set([tail, modelId, ...candidates])];
+}
 
 export function isStableOpenAiCodexModel(modelId) {
   if (!isOpenAiCodexProviderPrefix(modelId)) {
@@ -47,14 +45,15 @@ export function isStableOpenAiCodexModel(modelId) {
   return true;
 }
 
-export function listCodexModels() {
-  const executable = resolveCodexExecutable();
-  const child = spawnSync(executable.command, ["models"], {
-    encoding: "utf8",
-    windowsHide: true,
-    shell: executable.shell,
-    maxBuffer: 10 * 1024 * 1024,
-    timeout: Number.parseInt(process.env.CODEX_MODELS_TIMEOUT_MS ?? "30000", 10),
+export function listCodexModels() {
+  const executable = resolveCodexExecutable();
+  const child = spawnSync(executable.command, [...(executable.argsPrefix ?? []), "models"], {
+    encoding: "utf8",
+    windowsHide: true,
+    shell: executable.shell,
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 10 * 1024 * 1024,
+    timeout: Number.parseInt(process.env.CODEX_MODELS_TIMEOUT_MS ?? "30000", 10),
     killSignal: "SIGKILL",
   });
   if (child.error && child.error.code === "ETIMEDOUT") {

package/scripts/benchmark-edit-formats.mjs

@@ -63,7 +63,7 @@ function printUsage() {
     "  --help                           Show this help",
     "",
     "Examples:",
-    "  node scripts/benchmark-edit-formats.mjs --smoke --models=openai/gpt-5-codex",
+    "  node scripts/benchmark-edit-formats.mjs --smoke --models=openai/gpt-5.3-codex",
     "  node scripts/benchmark-edit-formats.mjs --preset=codex-core --warmup-runs=1 --measured-runs=5",
   ].join("\n"));
 }
@@ -588,12 +588,14 @@ function aggregateSummary({ options, runRecords, failures, startTime, endTime, e
       warmupRunsPerTask: options.warmupRuns,
       measuredRunsPerTask: options.measuredRuns,
       timeoutMs: options.timeoutMs,
-      outputRoot: options.outputRoot,
-      runDir: options.runDir,
-      homeDir: options.homeDir || null,
-      CodexCommand: executable.command,
-      CodexUsesShell: executable.shell,
-      keepRawLogs: options.keepRawLogs,
+      outputRoot: options.outputRoot,
+      runDir: options.runDir,
+      homeDir: options.homeDir || null,
+      CodexCommand: executable.command,
+      CodexArgsPrefix: executable.argsPrefix ?? [],
+      CodexShimCommand: executable.shimCommand ?? null,
+      CodexUsesShell: executable.shell,
+      keepRawLogs: options.keepRawLogs,
       runCount: measuredRuns.length,
       warmupCount: warmupRuns.length,
     },

package/scripts/check-pack-budget-lib.js

@@ -1,6 +1,15 @@
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 
+/**
+ * @typedef {{ packageSize: number, paths: string[] }} ParsedPackMetadata
+ * @typedef {{ windowsHide: boolean, maxBuffer: number }} ExecOptions
+ * @typedef {{ stdout: string | Buffer, stderr?: string | Buffer }} ExecResult
+ * @typedef {(command: string, options: ExecOptions) => Promise<ExecResult>} ExecAsync
+ * @typedef {{ execAsync?: ExecAsync, log?: (message: string) => void }} RunPackBudgetDeps
+ */
+
+/** @type {ExecAsync} */
 const execAsync = promisify(exec);
 
 export const MAX_PACKAGE_SIZE = 8 * 1024 * 1024;
@@ -25,18 +34,35 @@ export const FORBIDDEN_PREFIXES = [
 	".codex/",
 ];
 
+/**
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * @param {string} filePath
+ * @returns {string}
+ */
 export function normalizePackPath(filePath) {
 	return filePath.replaceAll("\\", "/");
 }
 
+/**
+ * @param {string} stdout
+ * @returns {ParsedPackMetadata}
+ */
 export function parsePackMetadata(stdout) {
+	/** @type {unknown} */
 	const packs = JSON.parse(stdout);
 	if (!Array.isArray(packs) || packs.length === 0) {
 		throw new Error("npm pack --dry-run --json returned no package metadata");
 	}
 
 	const pack = packs[0];
-	if (!pack || !Array.isArray(pack.files)) {
+	if (!isRecord(pack) || !Array.isArray(pack.files)) {
 		throw new Error("npm pack metadata did not include file list");
 	}
 
@@ -46,13 +72,17 @@ export function parsePackMetadata(stdout) {
 	}
 
 	const paths = pack.files
-		.map((file) => file?.path)
+		.map((file) => (isRecord(file) ? file.path : undefined))
 		.filter((value) => typeof value === "string")
 		.map((value) => normalizePackPath(value));
 
 	return { packageSize, paths };
 }
 
+/**
+ * @param {ParsedPackMetadata} metadata
+ * @returns {string}
+ */
 export function validatePackMetadata({ packageSize, paths }) {
 	if (packageSize > MAX_PACKAGE_SIZE) {
 		throw new Error(
@@ -83,20 +113,33 @@ export function validatePackMetadata({ packageSize, paths }) {
 	return `Pack budget ok: ${packageSize} bytes across ${paths.length} files`;
 }
 
+/**
+ * @param {RunPackBudgetDeps} [deps]
+ * @returns {Promise<string>}
+ */
 export async function runPackBudgetCheck(deps = {}) {
 	const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
 	const runExec = deps.execAsync ?? execAsync;
 	const log = deps.log ?? console.log;
 	let stdout = "";
 	try {
-		({ stdout } = await runExec(`${npmCommand} pack --dry-run --json`, {
+		const result = await runExec(`${npmCommand} pack --dry-run --json`, {
 			windowsHide: true,
 			maxBuffer: 10 * 1024 * 1024,
-		}));
+		});
+		if (result.stdout === null || result.stdout === undefined) {
+			throw new Error("npm pack --dry-run --json returned no stdout");
+		}
+		stdout =
+			typeof result.stdout === "string"
+				? result.stdout
+				: result.stdout.toString("utf8");
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		const stdoutText = typeof error === "object" && error && "stdout" in error ? String(error.stdout ?? "") : "";
-		const stderrText = typeof error === "object" && error && "stderr" in error ? String(error.stderr ?? "") : "";
+		const stdoutText =
+			isRecord(error) && "stdout" in error ? String(error.stdout ?? "") : "";
+		const stderrText =
+			isRecord(error) && "stderr" in error ? String(error.stderr ?? "") : "";
 		throw new Error(`npm pack --dry-run --json failed via ${npmCommand}: ${message}${stdoutText ? `
 stdout: ${stdoutText.slice(0, 500)}` : ""}${stderrText ? `
 stderr: ${stderrText.slice(0, 500)}` : ""}`);