codex-multi-auth 2.16.0 → 2.17.0

package/dist/lib/ui/ui-copy.js

@@ -144,8 +144,8 @@ export const UI_COPY = {
     fallback: {
         addAnotherTip: "Tip: Use private mode or sign out before adding another account.",
         addAnotherQuestion: (count) => `Add another account? (${count} added) (y/n): `,
-        selectModePrompt: "(a) add, (c) check, (b) best, fi(x), (s) settings, (d) deep, (g) problem, (f) fresh, (q) back [a/c/b/x/s/d/g/f/q]: ",
-        invalidModePrompt: "Use one of: a, c, b, x, s, d, g, f, q.",
+        selectModePrompt: "(api) API models, (a) add, (c) check, (b) best, fi(x), (s) settings, (d) deep, (g) problem, (f) fresh, (q) back [api/a/c/b/x/s/d/g/f/q]: ",
+        invalidModePrompt: "Use one of: api, a, c, b, x, s, d, g, f, q.",
     },
 };
 /**

package/dist/lib/usage/pricing.js

@@ -159,7 +159,7 @@ function normalizeModelName(model) {
     return trimmed && trimmed.length > 0 ? trimmed : null;
 }
 export function getUsageModelPricing(model) {
-    const normalized = normalizeModelName(model);
+    const normalized = normalizeModelName(model?.replace(/^(api|zdr)\//, ""));
     if (!normalized) {
         return null;
     }
@@ -177,7 +177,7 @@ export function getUsageModelPricing(model) {
     // `gpt-5.6-sol` request; pricing it at the retired model's old rate would
     // under-count a `maxCostUsd` budget. Rows already on disk are unaffected:
     // the ledger stores `costUsd` when a row is written and never re-prices it.
-    const effective = Object.hasOwn(RETIRED_MODEL_REPLACEMENTS, normalized)
+    const effective = !/^(api|zdr)\//.test(model ?? "") && Object.hasOwn(RETIRED_MODEL_REPLACEMENTS, normalized)
         ? RETIRED_MODEL_REPLACEMENTS[normalized]
         : normalized;
     if (!effective || !Object.hasOwn(MODEL_PRICING, effective)) {

package/dist/lib/usage/usage-extraction.d.ts

@@ -30,7 +30,7 @@ export interface UsageStreamScanner {
 /**
  * Observe a forwarded response body and recover its token counts.
  *
- * SSE bodies are scanned line by line so only the current partial line is
+ * SSE bodies are scanned frame by frame so only the current bounded event is
  * retained; a full response can be gigabytes of deltas and must never be
  * buffered. Non-SSE JSON bodies have no incremental structure to exploit, so
  * they are accumulated up to `MAX_BUFFERED_BYTES` and parsed at the end —
@@ -39,5 +39,7 @@ export interface UsageStreamScanner {
  */
 export declare function createUsageStreamScanner(options: {
     contentType?: string | null;
+    /** Observe parsed upstream events without reparsing the stream. */
+    onEvent?: (event: unknown) => void;
 }): UsageStreamScanner;
 //# sourceMappingURL=usage-extraction.d.ts.map

package/dist/lib/usage/usage-extraction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usage-extraction.d.ts","sourceRoot":"","sources":["../../../lib/usage/usage-extraction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA+BrE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,OAAO,GACZ,gBAAgB,GAAG,IAAI,CA+BzB;AAoCD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB,GAAG,IAAI,CAa/E;AAED,MAAM,WAAW,kBAAkB;IAClC,8CAA8C;IAC9C,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAClC,2EAA2E;IAC3E,MAAM,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAAC;CACtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IACjD,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,GAAG,kBAAkB,CA6ErB"}
+{"version":3,"file":"usage-extraction.d.ts","sourceRoot":"","sources":["../../../lib/usage/usage-extraction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA+BrE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,OAAO,GACZ,gBAAgB,GAAG,IAAI,CA+BzB;AAoCD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB,GAAG,IAAI,CAa/E;AAED,MAAM,WAAW,kBAAkB;IAClC,8CAA8C;IAC9C,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAClC,2EAA2E;IAC3E,MAAM,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAAC;CACtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IACjD,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,mEAAmE;IACnE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACnC,GAAG,kBAAkB,CAmGrB"}

package/dist/lib/usage/usage-extraction.js

@@ -124,7 +124,7 @@ export function extractResponsesUsage(payload) {
 /**
  * Observe a forwarded response body and recover its token counts.
  *
- * SSE bodies are scanned line by line so only the current partial line is
+ * SSE bodies are scanned frame by frame so only the current bounded event is
  * retained; a full response can be gigabytes of deltas and must never be
  * buffered. Non-SSE JSON bodies have no incremental structure to exploit, so
  * they are accumulated up to `MAX_BUFFERED_BYTES` and parsed at the end —
@@ -138,11 +138,20 @@ export function createUsageStreamScanner(options) {
     let bufferedBytes = 0;
     let overflowed = false;
     let latest = null;
-    const consumeLine = (line) => {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data:"))
+    let eventData = [];
+    let eventSize = 0;
+    let droppingEvent = false;
+    let droppingLine = false;
+    const consumeEvent = () => {
+        if (droppingEvent) {
+            droppingEvent = false;
+            eventData = [];
+            eventSize = 0;
             return;
-        const payload = trimmed.slice("data:".length).trim();
+        }
+        const payload = eventData.join("\n");
+        eventData = [];
+        eventSize = 0;
         if (payload.length === 0 || payload === "[DONE]")
             return;
         let parsed;
@@ -152,6 +161,7 @@ export function createUsageStreamScanner(options) {
         catch {
             return;
         }
+        options.onEvent?.(parsed);
         // Prefer terminal events, which carry the authoritative totals, but fall
         // back to any event that reports usage so a stream that ends on a
         // non-standard terminal type still records something.
@@ -162,6 +172,24 @@ export function createUsageStreamScanner(options) {
             latest = counts;
         }
     };
+    const consumeLine = (raw) => {
+        const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        if (line.length === 0) {
+            consumeEvent();
+            return;
+        }
+        if (droppingEvent || !line.startsWith("data:"))
+            return;
+        const value = line.slice(5).replace(/^ /, "");
+        eventSize += value.length + 1;
+        if (eventSize > MAX_BUFFERED_BYTES) {
+            droppingEvent = true;
+            eventData = [];
+            eventSize = 0;
+            return;
+        }
+        eventData.push(value);
+    };
     return {
         push: (chunk) => {
             try {
@@ -178,14 +206,20 @@ export function createUsageStreamScanner(options) {
                 }
                 let newlineAt = pending.indexOf("\n");
                 while (newlineAt !== -1) {
-                    consumeLine(pending.slice(0, newlineAt));
+                    if (droppingLine)
+                        droppingLine = false;
+                    else
+                        consumeLine(pending.slice(0, newlineAt));
                     pending = pending.slice(newlineAt + 1);
                     newlineAt = pending.indexOf("\n");
                 }
                 // A single unterminated line this long is not SSE any more; stop
                 // retaining it rather than growing the buffer for the whole body.
-                if (pending.length > MAX_BUFFERED_BYTES) {
-                    overflowed = true;
+                if (pending.length > MAX_BUFFERED_BYTES || droppingLine) {
+                    droppingEvent = true;
+                    droppingLine = true;
+                    eventData = [];
+                    eventSize = 0;
                     pending = "";
                 }
             }
@@ -202,13 +236,16 @@ export function createUsageStreamScanner(options) {
                     if (pending.length > 0)
                         consumeLine(pending);
                     pending = "";
+                    consumeEvent();
                     return latest;
                 }
                 if (pending.trim().length === 0)
                     return latest;
                 const parsed = JSON.parse(pending);
                 pending = "";
-                return extractResponsesUsage(parsed) ?? latest;
+                options.onEvent?.(parsed);
+                latest = extractResponsesUsage(parsed) ?? latest;
+                return latest;
             }
             catch {
                 return latest;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "codex-multi-auth",
-	"version": "2.16.0",
+	"version": "2.17.0",
 	"description": "Codex CLI multi-account OAuth manager with account switching, health checks, runtime rotation, diagnostics, and recovery tools for @openai/codex",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -157,6 +157,7 @@
 	},
 	"devDependencies": {
 		"@types/node": "^20.19.42",
+		"@types/ws": "8.18.1",
 		"@typescript-eslint/eslint-plugin": "^8.56.0",
 		"@typescript-eslint/parser": "^8.56.0",
 		"@vitest/coverage-v8": "^4.1.8",
@@ -174,12 +175,13 @@
 	"dependencies": {
 		"@codex-ai/plugin": "file:vendor/codex-ai-plugin",
 		"@codex-ai/sdk": "file:vendor/codex-ai-sdk",
-		"hono": "4.12.33",
+		"hono": "4.13.9",
 		"undici": "6.28.0",
+		"ws": "8.21.3",
 		"zod": "4.4.3"
 	},
 	"overrides": {
-		"hono": "4.12.33",
+		"hono": "4.13.9",
 		"flatted": "3.4.2",
 		"minimatch": "10.2.4",
 		"picomatch": "4.0.4",
@@ -192,6 +194,7 @@
 			"minimatch": "9.0.9"
 		},
 		"brace-expansion": "5.0.9",
-		"postcss": "8.5.25"
+		"postcss": "8.5.25",
+		"nanoid": "3.3.18"
 	}
 }

package/scripts/codex-app-router.js

@@ -177,11 +177,16 @@ function createStatusPayload({
 		baseUrl: proxyServer?.baseUrl ?? stateRecord?.baseUrl ?? null,
 		totalRequests: proxyStatus.totalRequests ?? 0,
 		upstreamRequests: proxyStatus.upstreamRequests ?? 0,
+		websocketConnections: proxyStatus.websocketConnections ?? 0,
+		websocketUpstreamRequests: proxyStatus.websocketUpstreamRequests ?? 0,
+		streamQuotaUpdates: proxyStatus.streamQuotaUpdates ?? 0,
+		lastStreamQuotaUpdateAt: proxyStatus.lastStreamQuotaUpdateAt ?? null,
 		retries: proxyStatus.retries ?? 0,
 		rotations: proxyStatus.rotations ?? 0,
 		lastAccountIndex,
 		lastAccountLabel,
 		lastAccountId: proxyStatus.lastAccountId ?? null,
+		lastRequestedWorkspaceId: proxyStatus.lastRequestedWorkspaceId ?? null,
 		lastAccountUpdatedAt: proxyStatus.lastAccountUpdatedAt ?? null,
 		lastError: error ? (error instanceof Error ? error.message : String(error)) : proxyStatus.lastError ?? null,
 	};
@@ -323,6 +328,8 @@ async function main() {
 	try {
 		const proxyModule = await import("../dist/lib/runtime-rotation-proxy.js");
 		proxyServer = await proxyModule.startRuntimeRotationProxy({
+			nativeOpenai: stateRecord?.nativeOpenai === true,
+			catalogAccount: stateRecord?.catalogAccount,
 			host,
 			port,
 			clientApiKey,

package/scripts/codex-bin-resolver.js

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
-import { basename, delimiter, dirname, extname, isAbsolute, join, relative } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, posix, relative, win32 } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 
@@ -55,6 +55,29 @@ function defaultResolvePackageBin(moduleUrl) {
 	}
 }
 
+// spawn() without a shell cannot run these on Windows: `.cmd`/`.bat` are
+// EINVAL, `.ps1` is not an executable image, and an extensionless file
+// (npm's `#!/bin/sh` shim) is ENOENT even when it is a real PE image. Going through cmd.exe instead would put every
+// forwarded argument through cmd's quoting rules.
+export function isWindowsShimPath(candidatePath) {
+	const extension = win32.extname(candidatePath).toLowerCase();
+	return extension === "" || extension === ".cmd" || extension === ".bat" || extension === ".ps1";
+}
+
+// npm's Windows shims sit in the prefix dir and run
+// `<prefix>\node_modules\@openai\codex\bin\codex.js`.
+export function resolveWindowsShimPackageEntry(shimPath, existsSyncImpl = existsSync) {
+	const entry = win32.join(
+		win32.dirname(shimPath),
+		"node_modules",
+		"@openai",
+		"codex",
+		"bin",
+		"codex.js",
+	);
+	return existsSyncImpl(entry) ? entry : null;
+}
+
 function resolveWindowsCmdPath(env) {
 	const comSpec = (env.ComSpec ?? env.COMSPEC ?? "").trim();
 	if (comSpec.length > 0) return comSpec;
@@ -67,12 +90,12 @@ function resolveWindowsCmdPath(env) {
 	return "cmd.exe";
 }
 
-export function splitPathEntries(pathValue) {
+export function splitPathEntries(pathValue, platform = process.platform) {
 	if (typeof pathValue !== "string" || pathValue.trim().length === 0) {
 		return [];
 	}
 	return pathValue
-		.split(delimiter)
+		.split(platform === "win32" ? ";" : ":")
 		.map((entry) => entry.trim())
 		.filter((entry) => entry.length > 0);
 }
@@ -85,7 +108,12 @@ function resolveCandidateExecutableNames(platform) {
 	if (platform !== "win32") {
 		return [resolvePathExecutableName(platform)];
 	}
-	return ["codex.exe", "codex"];
+	// npm on Windows puts `codex.cmd` plus an extensionless `#!/bin/sh` shim in
+	// the prefix dir and the package under `<prefix>\node_modules`. Neither shim
+	// can be spawned without a shell (`.cmd` is EINVAL, the sh script ENOENT),
+	// so launch the package entry the shims point at before falling back to an
+	// extensionless `codex`.
+	return ["codex.exe", win32.join("node_modules", "@openai", "codex", "bin", "codex.js"), "codex"];
 }
 
 function resolveCodexExecutableFromPath(
@@ -97,7 +125,7 @@ function resolveCodexExecutableFromPath(
 ) {
 	for (const entry of pathEntries) {
 		for (const executableName of resolveCandidateExecutableNames(platform)) {
-			const candidate = join(entry, executableName);
+			const candidate = (platform === "win32" ? win32 : posix).join(entry, executableName);
 			if (!existsSyncImpl(candidate)) {
 				continue;
 			}
@@ -134,7 +162,7 @@ function resolveCodexExecutableFromSystemPath(
 	selfScriptPath,
 	realpathSyncImpl,
 ) {
-	const pathEntries = splitPathEntries(env.PATH ?? env.Path ?? "");
+	const pathEntries = splitPathEntries(env.PATH ?? env.Path ?? "", platform);
 	const fromEnvPath = resolveCodexExecutableFromPath(
 		pathEntries,
 		platform,
@@ -207,8 +235,12 @@ export function resolveRealCodexBin(options = {}) {
 
 	const override = (env.CODEX_MULTI_AUTH_REAL_CODEX_BIN ?? "").trim();
 	if (override.length > 0) {
-		if (existsSyncImpl(override)) return createResolvedCodexBin(override);
-		return null;
+		if (!existsSyncImpl(override)) return null;
+		if (platform === "win32" && isWindowsShimPath(override)) {
+			const entry = resolveWindowsShimPackageEntry(override, existsSyncImpl);
+			return entry ? createResolvedCodexBin(entry) : null;
+		}
+		return createResolvedCodexBin(override);
 	}
 
 	const resolved = resolvePackageBin(moduleUrl);

package/scripts/codex-routing.js

@@ -10,6 +10,7 @@ const AUTH_SUBCOMMANDS = new Set([
 	"check",
 	"features",
 	"usage",
+	"resets",
 	"verify-flagged",
 	"verify",
 	"forecast",

package/scripts/codex.js

@@ -26,7 +26,9 @@ import process from "node:process";
 import { StringDecoder } from "node:string_decoder";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import {
+	isWindowsShimPath,
 	resolveRealCodexBin as resolveRealCodexBinFromEnvironment,
+	resolveWindowsShimPackageEntry,
 	splitPathEntries,
 } from "./codex-bin-resolver.js";
 import { normalizeAuthAlias, shouldHandleMultiAuthAuth } from "./codex-routing.js";
@@ -1350,6 +1352,17 @@ function resolveRealCodexBin() {
 			);
 			return null;
 		}
+		if (
+			process.platform === "win32" &&
+			isWindowsShimPath(override) &&
+			!resolveWindowsShimPackageEntry(override)
+		) {
+			console.error(
+				`CODEX_MULTI_AUTH_REAL_CODEX_BIN points at a script shim that cannot be launched directly on Windows: ${override}\n` +
+					"Point it at codex.exe or @openai/codex/bin/codex.js instead.",
+			);
+			return null;
+		}
 		return resolveRealCodexBinFromEnvironment({
 			moduleUrl: import.meta.url,
 			env: process.env,
@@ -3599,7 +3612,16 @@ function parseRuntimeRotationProxyEnv(value) {
 	return undefined;
 }
 
+function hasNativeAppBinding(env = process.env) {
+	try {
+		const config = readFileSync(join(resolveCodexHomeDir(env), "config.toml"), "utf8");
+		return config.includes("# codex-multi-auth native provider begin") &&
+			extractConfigAssignmentValue(config, "model_provider") === "openai";
+	} catch { return false; }
+}
+
 async function isRuntimeRotationProxyEnabled(rawArgs, baseEnv = process.env) {
+	if (hasNativeAppBinding(baseEnv)) return false;
 	if ((baseEnv.CODEX_MULTI_AUTH_BYPASS ?? "").trim() === "1") {
 		return false;
 	}
@@ -4021,29 +4043,20 @@ function installRuntimeRotationAppServerCliShim(forwardedEnv, configArgs = []) {
 			// Best-effort stale shim cleanup only; the copy below will report a
 			// persistent failure without leaving a partially-created helper.
 		}
-		if (
-			process.platform === "win32" ||
-			(process.env.CODEX_MULTI_AUTH_TEST_FORCE_APP_SERVER_SHIM_COPY ?? "") === "1"
-		) {
-			// A Windows hard link to the running node.exe remains locked by the
-			// helper process itself, which prevents the shim directory from being
-			// removed during graceful helper shutdown. Use an independent image so
-			// the helper can clean up its app-server shim before exiting.
+		if (process.platform === "win32") {
+			// A running hard-linked node.exe prevents helper cleanup on Windows.
 			withSynchronousFileOperationRetry(() => {
 				maybeThrowSimulatedAppServerShimFileError("copy");
 				copyFileSync(process.execPath, executablePath);
 			});
 		} else {
-			try {
-				linkSync(process.execPath, executablePath);
-			} catch {
-				withSynchronousFileOperationRetry(() => {
-					maybeThrowSimulatedAppServerShimFileError("copy");
-					copyFileSync(process.execPath, executablePath);
-				});
-			}
-		}
-		if (process.platform !== "win32") {
+			// Relocating Node breaks installations with executable-relative shared
+			// libraries (including Homebrew). Invoke the original image in place.
+			const quotedNode = "'" + process.execPath.replace(/'/g, "'\\''") + "'";
+			withSynchronousFileOperationRetry(() => {
+				maybeThrowSimulatedAppServerShimFileError("copy");
+				writeFileSync(executablePath, `#!/bin/sh\nexec ${quotedNode} "$@"\n`, { mode: 0o755 });
+			});
 			chmodSync(executablePath, 0o755);
 		}
 		writeFileSync(
@@ -5964,8 +5977,13 @@ function createCompatibilityCodexHome(
 	};
 }
 
-function buildForwardArgs(rawArgs) {
-	const { args: compatibilityArgs, requestedModel } = rewriteReasoningConfigArgs(rawArgs);
+function buildForwardArgs(rawArgs, { preserveNativeSettings = false } = {}) {
+	// Native app binding keeps the caller's model and reasoning settings verbatim;
+	// it still needs the file auth store, because the router authenticates the
+	// desktop token it reads from auth.json.
+	const { args: compatibilityArgs, requestedModel } = preserveNativeSettings
+		? { args: [...rawArgs], requestedModel: extractRequestedModel(rawArgs) }
+		: rewriteReasoningConfigArgs(rawArgs);
 	const forceFileAuthStore = (process.env.CODEX_MULTI_AUTH_FORCE_FILE_AUTH_STORE ?? "1").trim() !== "0";
 	if (!forceFileAuthStore) {
 		return { args: compatibilityArgs, requestedModel };
@@ -6473,6 +6491,33 @@ function ensureWindowsShellShimGuards() {
 	}
 }
 
+export function getResumePickerRequest(args, cwd = process.cwd()) {
+	const baseCwd = cwd;
+	const command = findForwardedCommand(args);
+	if (command?.command !== "resume" || findForwardedSubcommand(args, command.index)) return null;
+	const configArgs = [];
+	let showAll = false;
+	let includeNonInteractive = false;
+	for (let i = 0; i < args.length; i += 1) {
+		const arg = args[i];
+		if (arg === "--") break;
+		if (consumesNextArg(arg) && args[i + 1] === undefined) return null;
+		if (["--last", "--help", "-h", "--remote"].includes(arg) || arg.startsWith("--remote=")) return null;
+		if (arg === "--all") showAll = true;
+		if (arg === "--include-non-interactive") includeNonInteractive = true;
+		if (arg === "-C" || arg === "--cd") cwd = resolvePath(baseCwd, args[i + 1]);
+		else if (arg.startsWith("--cd=")) cwd = resolvePath(baseCwd, arg.slice(5));
+		else if (arg.startsWith("-C") && arg.length > 2) cwd = resolvePath(baseCwd, arg.slice(2));
+		if (["-c", "--config", "-p", "--profile", "--enable", "--disable"].includes(arg)) {
+			configArgs.push(arg, args[i + 1]);
+		} else if (/^--(config|profile|enable|disable)=/.test(arg) || /^-[cp].+/.test(arg)) {
+			configArgs.push(arg);
+		}
+		i = skipOptionValueSpan(args, i);
+	}
+	return { commandIndex: command.index, cwd, configArgs, showAll, includeNonInteractive };
+}
+
 async function main() {
 	hydrateCliVersionEnv();
 
@@ -6513,7 +6558,9 @@ async function main() {
 			[
 				"Could not locate the official Codex CLI.",
 				"Install it with npm, Homebrew, or an official native release so `codex` is on PATH.",
-				"Or set CODEX_MULTI_AUTH_REAL_CODEX_BIN to the full path of either codex or @openai/codex/bin/codex.js.",
+				process.platform === "win32"
+					? "Or set CODEX_MULTI_AUTH_REAL_CODEX_BIN to the full path of codex.exe or @openai/codex/bin/codex.js."
+					: "Or set CODEX_MULTI_AUTH_REAL_CODEX_BIN to the full path of either codex or @openai/codex/bin/codex.js.",
 			].join("\n"),
 		);
 		return 1;
@@ -6522,12 +6569,42 @@ async function main() {
 	// Resolve `--account` / CODEX_MULTI_AUTH_FORCE_ACCOUNT before forwarding: strip
 	// the launcher-only flag from the Codex args and publish the resolved pin, or
 	// fail hard so a forced account can never silently fall back to another one.
+	if (hasNativeAppBinding(process.env)) {
+        const forced = resolveForcedAccountSelector(rawArgs, process.env);
+        if (forced.error || forced.selector !== null) {
+            console.error(forced.error ?? "Native app binding uses the persistent inference selection. Use codex-multi-auth switch instead of --account.");
+            return 1;
+        }
+        delete process.env.CODEX_MULTI_AUTH_FORCE_ACCOUNT_INDEX;
+        // Best effort: a locked or read-only config.toml (Windows EPERM/EBUSY)
+        // must not block the launch; the per-invocation override below still applies.
+        await ensurePersistedCodexFileAuthStore();
+        const { args: nativeArgs } = buildForwardArgs(forced.strippedArgs, { preserveNativeSettings: true });
+        const result = await forwardToRealCodexOnce(realCodexBin, nativeArgs, process.env);
+        return result.exitCode;
+    }
 	const forcedAccount = await applyForcedAccountSelection(rawArgs, process.env);
 	if (forcedAccount.error) {
 		console.error(forcedAccount.error);
 		return 1;
 	}
-	const forwardArgs = forcedAccount.forwardArgs;
+	const forwardArgs = [...forcedAccount.forwardArgs];
+
+
+	if (process.stdin.isTTY && process.stdout.isTTY && !bypass) {
+		const pickerRequest = getResumePickerRequest(forwardArgs);
+		if (pickerRequest && await isRuntimeRotationProxyEnabled(forwardArgs)) {
+			try {
+				const { pickResumeThread } = await import("../dist/lib/runtime/resume-picker.js");
+				const id = await pickResumeThread({ ...pickerRequest, codexBin: realCodexBin });
+				if (!id) return 0;
+				forwardArgs.splice(pickerRequest.commandIndex + 1, 0, id);
+			} catch (error) {
+				// Discovery is optional: fall back to native `codex resume` with the original args.
+				console.error(`Could not list saved Codex sessions: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	}
 
 	await ensurePersistedCodexFileAuthStore();
 	await autoSyncManagerActiveSelectionIfEnabled();
@@ -6546,6 +6623,7 @@ async function main() {
 // lib/request/helpers/model-map.ts (see test/codex-model-resolution.test.ts,
 // which asserts wrapper<->lib parity).
 export {
+	isRuntimeRotationProxyEnabled,
 	normalizeRequestedModel,
 	coerceReasoningEffortForModel,
 	resolveModelFamilyForStatus,