codex-multi-auth 2.1.2 → 2.1.4

package/scripts/codex.js

@@ -89,6 +89,7 @@ const shadowHomeCleanupRetryMarkerDir =
 	(process.env.CODEX_MULTI_AUTH_TEST_SHADOW_RETRY_MARKER_DIR ?? "").trim();
 let warnedInvalidRuntimeRotationProxyEnv = false;
 let warnedPendingAccountReadIdOverflow = false;
+let warnedShadowHomeSqliteLinkFailure = false;
 
 async function loadRuntimeConstants() {
 	const fallback = {
@@ -579,6 +580,9 @@ function shouldCaptureForwardedCodexOutput(env = process.env) {
 	if (override === "0") {
 		return false;
 	}
+	if ((env.CODEX_CI ?? "").trim() === "1") {
+		return true;
+	}
 	// Windows child processes can report undefined isTTY; treat that as non-TTY so retry capture remains available.
 	return process.stdout.isTTY !== true || process.stderr.isTTY !== true;
 }
@@ -764,6 +768,57 @@ function rewriteAppServerAccountReadResponseLine(line, pendingAuthRequestMethods
 	})}${lineEnding}`;
 }
 
+function filterKnownForwardedCodexStderr(text) {
+	if (typeof text !== "string" || text.length === 0) {
+		return "";
+	}
+	const lines = text.split(/\r?\n/);
+	const filtered = [];
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (
+			/ERROR codex_core::session: failed to record rollout items: thread\s*$/.test(
+				line,
+			) &&
+			/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12} not found$/i.test(
+				lines[index + 1] ?? "",
+			)
+		) {
+			index += 1;
+			continue;
+		}
+		if (
+			/ERROR rmcp::transport::streamable_http_client: fail to delete session:\s*$/.test(
+				line,
+			) &&
+			/^unexpected server response: DELETE returned HTTP 404 session_id="/.test(
+				lines[index + 1] ?? "",
+			)
+		) {
+			index += 1;
+			while (index + 1 < lines.length && !/"\s*$/.test(lines[index])) {
+				index += 1;
+			}
+			continue;
+		}
+		filtered.push(line);
+	}
+	return filtered.join("\n");
+}
+
+function withCiKnownForwardedCodexLogSilencers(env) {
+	if ((env.CODEX_CI ?? "").trim() !== "1") {
+		return env;
+	}
+	if ((env.RUST_LOG ?? "").trim().length > 0) {
+		return env;
+	}
+	return {
+		...env,
+		RUST_LOG: "codex_core::session=off",
+	};
+}
+
 function forwardToRealCodexOnce(
 	codexBin,
 	args,
@@ -794,6 +849,21 @@ function forwardToRealCodexOnce(
 			} catch {
 				// Best-effort cleanup only.
 			}
+			if (captureOutput && stdout.length > 0) {
+				const filteredStdout = filterKnownForwardedCodexStderr(stdout);
+				if (filteredStdout.length > 0) {
+					process.stdout.write(filteredStdout);
+				}
+			}
+			if (captureOutput && stderr.length > 0) {
+				const filteredStderr = filterKnownForwardedCodexStderr(stderr);
+				if (filteredStderr.trim().length > 0) {
+					process.stderr.write(filteredStderr);
+					if (!filteredStderr.endsWith("\n")) {
+						process.stderr.write("\n");
+					}
+				}
+			}
 			resolve({
 				exitCode,
 				// No-capture output stays empty by design so retry parsing cannot
@@ -812,13 +882,16 @@ function forwardToRealCodexOnce(
 			finalize(1);
 		};
 		try {
+			const childEnv = captureOutput
+				? withCiKnownForwardedCodexLogSilencers(env)
+				: env;
 			child = spawn(command, commandArgs, {
 				stdio: proxyAppServerAccountRead
 					? ["pipe", "pipe", "pipe"]
 					: captureOutput
 						? ["inherit", "pipe", "pipe"]
 						: "inherit",
-				env,
+				env: childEnv,
 			});
 		} catch (error) {
 			failLaunch(error);
@@ -883,12 +956,10 @@ function forwardToRealCodexOnce(
 			child.stdout?.on("data", (chunk) => {
 				const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
 				stdout += text;
-				process.stdout.write(chunk);
 			});
 			child.stderr?.on("data", (chunk) => {
 				const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
 				stderr += text;
-				process.stderr.write(chunk);
 			});
 		}
 
@@ -948,6 +1019,7 @@ async function forwardToRealCodex(codexBin, rawArgs, baseEnv = process.env) {
 		);
 		lastExitCode = result.exitCode;
 		if (result.exitCode === 0) {
+			repairCodexSessionIndex(resolveCodexHomeDir(baseEnv));
 			return result.exitCode;
 		}
 
@@ -1831,6 +1903,25 @@ function mirrorFileIntoShadowHome(sourcePath, destinationPath, tightenFile) {
 	tightenFile(destinationPath);
 }
 
+function shouldMaterializeFileIntoShadowHome(name) {
+	return /\.sqlite(?:-(?:shm|wal))?$/i.test(name);
+}
+
+function materializeFileIntoShadowHome(sourcePath, destinationPath) {
+	try {
+		linkSync(sourcePath, destinationPath);
+		return true;
+	} catch {
+		if (!warnedShadowHomeSqliteLinkFailure) {
+			warnedShadowHomeSqliteLinkFailure = true;
+			console.error(
+				"codex-multi-auth: skipped SQLite shadow-home materialization because hard-linking failed; refusing to copy active SQLite state.",
+			);
+		}
+	}
+	return false;
+}
+
 function collectShadowHomeSyncFileNames(shadowCodexHome, syncFileNames) {
 	try {
 		for (const entry of readdirSync(shadowCodexHome, { withFileTypes: true })) {
@@ -2004,6 +2095,7 @@ function createShadowHomeMirror(
 				continue;
 			}
 			const isKnownStateFile = SHADOW_HOME_STATE_FILE_SET.has(name);
+			const shouldMaterializeFile = shouldMaterializeFileIntoShadowHome(name);
 			const sourcePath = join(originalCodexHome, name);
 			const destinationPath = join(shadowCodexHome, name);
 			if (existsSync(destinationPath)) {
@@ -2032,6 +2124,8 @@ function createShadowHomeMirror(
 					if (isKnownStateFile) {
 						copyFileSync(sourcePath, destinationPath);
 						tightenFile(destinationPath);
+					} else if (shouldMaterializeFile) {
+						materializeFileIntoShadowHome(sourcePath, destinationPath);
 					} else {
 						mirrorFileIntoShadowHome(sourcePath, destinationPath, tightenFile);
 					}
@@ -2195,6 +2289,16 @@ function resolveRuntimeRotationProxyOriginalCodexHome(baseEnv) {
 	return override || resolveCodexHomeDir(baseEnv);
 }
 
+function createRuntimeRotationShadowHome(originalCodexHome) {
+	const shadowRoot = join(
+		originalCodexHome,
+		"multi-auth",
+		"runtime-shadow-homes",
+	);
+	mkdirSync(shadowRoot, { recursive: true });
+	return mkdtempSync(join(shadowRoot, "codex-multi-auth-runtime-home-"));
+}
+
 function createRuntimeRotationProxyCodexHome(
 	baseEnv,
 	proxyBaseUrl,
@@ -2202,7 +2306,7 @@ function createRuntimeRotationProxyCodexHome(
 	configTomlModule,
 ) {
 	const originalCodexHome = resolveRuntimeRotationProxyOriginalCodexHome(baseEnv);
-	const shadowCodexHome = mkdtempSync(join(tmpdir(), "codex-multi-auth-runtime-home-"));
+	const shadowCodexHome = createRuntimeRotationShadowHome(originalCodexHome);
 	let syncShadowHomeStateBack = () => {};
 	const cleanup = () => {
 		try {
@@ -2770,7 +2874,11 @@ function startRuntimeRotationAppHelper(baseContext) {
 	});
 }
 
-async function createRuntimeRotationAppHelperContext(baseContext, configTomlModule) {
+async function createRuntimeRotationAppHelperContext(
+	baseContext,
+	configTomlModule,
+	options = {},
+) {
 	const startedAt = Date.now();
 	const { helper, message } = await startRuntimeRotationAppHelper(baseContext);
 	const helperEnv = message.env ?? {};
@@ -2778,7 +2886,7 @@ async function createRuntimeRotationAppHelperContext(baseContext, configTomlModu
 
 	const cleanup = async ({ exitCode } = {}) => {
 		const livedMs = Date.now() - startedAt;
-		if (exitCode === 0 && livedMs < detachGraceMs) {
+		if (exitCode === 0 && (options.detachOnExit === true || livedMs < detachGraceMs)) {
 			helper.stdout?.destroy();
 			helper.stderr?.destroy();
 			helper.unref();
@@ -2827,6 +2935,11 @@ async function createRuntimeRotationProxyContextIfEnabled(
 	if (isCodexAppCommand(rawArgs)) {
 		return createRuntimeRotationAppHelperContext(baseContext, configTomlModule);
 	}
+	if (isCodexInteractiveTuiCommand(rawArgs)) {
+		return createRuntimeRotationAppHelperContext(baseContext, configTomlModule, {
+			detachOnExit: true,
+		});
+	}
 
 	const proxyModule = await loadRuntimeRotationProxyModule();
 	if (!proxyModule) {
@@ -3021,6 +3134,10 @@ function isCodexAppServerCommand(rawArgs) {
 	return findForwardedCommand(rawArgs)?.command === "app-server";
 }
 
+function isCodexInteractiveTuiCommand(rawArgs) {
+	return findForwardedCommand(rawArgs) === null;
+}
+
 function shouldUseRuntimeRoutingForForwardedArgs(rawArgs) {
 	if (!Array.isArray(rawArgs) || rawArgs.length === 0) {
 		return true;
@@ -3273,6 +3390,175 @@ function normalizeExitCode(value) {
 	return 1;
 }
 
+function extractRolloutIdFromFilename(fileName) {
+	const match = fileName.match(
+		/^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i,
+	);
+	return match?.[1] ?? null;
+}
+
+function collectRolloutFiles(rootDir, results = []) {
+	let entries = [];
+	try {
+		entries = readdirSync(rootDir, { withFileTypes: true });
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const entryPath = join(rootDir, entry.name);
+		if (entry.isDirectory()) {
+			collectRolloutFiles(entryPath, results);
+			continue;
+		}
+		if (entry.isFile() && extractRolloutIdFromFilename(entry.name)) {
+			results.push(entryPath);
+		}
+	}
+	return results;
+}
+
+function parseRolloutIndexEntry(rolloutPath) {
+	const fileName = basename(rolloutPath);
+	const idFromName = extractRolloutIdFromFilename(fileName);
+	if (!idFromName) return null;
+	let content = "";
+	try {
+		content = readFileSync(rolloutPath, "utf8");
+	} catch {
+		return null;
+	}
+	const lines = content.split(/\r?\n/).filter(Boolean);
+	let id = idFromName;
+	let threadName = "";
+	let updatedAt = null;
+	let hasSessionMeta = false;
+	for (const line of lines) {
+		let record;
+		try {
+			record = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (typeof record?.timestamp === "string") {
+			updatedAt = record.timestamp;
+		}
+		if (record?.type === "session_meta" && typeof record.payload?.id === "string") {
+			id = record.payload.id;
+			hasSessionMeta = true;
+		}
+		if (!threadName && record?.type === "event_msg") {
+			const message = record.payload?.message;
+			if (typeof message === "string" && message.trim().length > 0) {
+				threadName = message.trim();
+			}
+		}
+	}
+	if (!updatedAt) {
+		try {
+			updatedAt = statSync(rolloutPath).mtime.toISOString();
+		} catch {
+			updatedAt = new Date().toISOString();
+		}
+	}
+	if (!threadName) {
+		threadName = "Codex session";
+	}
+	if (!hasSessionMeta) {
+		return null;
+	}
+	if (threadName.length > 80) {
+		threadName = `${threadName.slice(0, 77)}...`;
+	}
+	return { id, thread_name: threadName, updated_at: updatedAt };
+}
+
+function writeSessionIndexAtomicSync(indexPath, lines) {
+	const indexDir = dirname(indexPath);
+	mkdirSync(indexDir, { recursive: true });
+	for (let attempt = 0; attempt <= SHADOW_HOME_CLEANUP_BACKOFF_MS.length; attempt += 1) {
+		const tempPath = join(
+			indexDir,
+			[
+				`.${basename(indexPath)}`,
+				String(process.pid),
+				String(Date.now()),
+				randomBytes(4).toString("hex"),
+				"tmp",
+			].join("."),
+		);
+		try {
+			writeFileSync(tempPath, `${lines.join("\n")}\n`, {
+				encoding: "utf8",
+				mode: 0o600,
+			});
+			chmodSync(tempPath, 0o600);
+			renameSync(tempPath, indexPath);
+			chmodSync(indexPath, 0o600);
+			return;
+		} catch (error) {
+			try {
+				rmSync(tempPath, { force: true });
+			} catch {
+				// Preserve the original write failure.
+			}
+			if (
+				isRetryableShadowHomeCleanupError(error) &&
+				attempt < SHADOW_HOME_CLEANUP_BACKOFF_MS.length
+			) {
+				sleepSync(SHADOW_HOME_CLEANUP_BACKOFF_MS[attempt]);
+				continue;
+			}
+			throw error;
+		}
+	}
+}
+
+function repairCodexSessionIndex(codexHome) {
+	if (!codexHome || typeof codexHome !== "string") return;
+	const sessionsDir = join(codexHome, "sessions");
+	if (!existsSync(sessionsDir)) return;
+	const indexPath = join(codexHome, "session_index.jsonl");
+	let releaseLock = null;
+	try {
+		releaseLock = acquireShadowHomeSyncLock(codexHome);
+		const seen = new Set();
+		let existingLines = [];
+		if (existsSync(indexPath)) {
+			existingLines = readFileSync(indexPath, "utf8")
+				.split(/\r?\n/)
+				.filter(Boolean);
+			for (const line of existingLines) {
+				try {
+					const entry = JSON.parse(line);
+					if (typeof entry?.id === "string") {
+						seen.add(entry.id);
+					}
+				} catch {
+					// Preserve unparsable existing lines.
+				}
+			}
+		}
+
+		const additions = [];
+		for (const rolloutPath of collectRolloutFiles(sessionsDir)) {
+			const entry = parseRolloutIndexEntry(rolloutPath);
+			if (!entry || seen.has(entry.id)) continue;
+			seen.add(entry.id);
+			additions.push(entry);
+		}
+		if (additions.length === 0) return;
+		additions.sort((a, b) => a.updated_at.localeCompare(b.updated_at));
+		writeSessionIndexAtomicSync(indexPath, [
+			...existingLines,
+			...additions.map((entry) => JSON.stringify(entry)),
+		]);
+	} catch {
+		// Best-effort repair only; forwarding must not fail because indexing did.
+	} finally {
+		releaseLock?.();
+	}
+}
+
 const WINDOWS_SHIM_MARKER = "codex-multi-auth windows shim guardian v1";
 const POWERSHELL_PROFILE_MARKER_START = "# >>> codex-multi-auth shell guard >>>";
 const POWERSHELL_PROFILE_MARKER_END = "# <<< codex-multi-auth shell guard <<<";

package/scripts/test-model-matrix.js

@@ -110,6 +110,7 @@ function printUsage() {
 			"  --plugin=dist|package          Load plugin from local dist URI or package name (default: dist)",
 			"  --max-cases=N                  Hard cap number of cases per scenario",
 			"  --report-json=PATH             Write JSON report to PATH (relative to repo root)",
+			"  --strict-capabilities          Fail unsupported account/model capabilities instead of skipping them",
 			"  --no-restore                   Keep generated local config files after run",
 			"  -h, --help                     Show help",
 		].join("\n"),
@@ -148,6 +149,15 @@ function runQuiet(command, commandArgs) {
 	}
 }
 
+function runQuietWindowsTaskkill(pid) {
+	runQuiet("cmd.exe", [
+		"/d",
+		"/s",
+		"/c",
+		`taskkill /F /T /PID ${pid}`,
+	]);
+}
+
 export function registerSpawnedCodex(pid) {
 	if (!Number.isInteger(pid) || pid <= 0) return;
 	spawnedCodexPids.add(pid);
@@ -171,18 +181,67 @@ export function resolveMatrixTimeoutMs(smoke = false) {
 	return parsedTimeout;
 }
 
-function hasCompletedSuccessfully(output, token) {
+function parseNdjsonEvents(output) {
+	const events = [];
+	for (const line of output.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed.startsWith("{")) {
+			continue;
+		}
+		try {
+			events.push(JSON.parse(trimmed));
+		} catch {
+			// Ignore wrapper noise and partial lines.
+		}
+	}
+	return events;
+}
+
+function findLastIndex(items, predicate) {
+	for (let index = items.length - 1; index >= 0; index -= 1) {
+		if (predicate(items[index], index)) {
+			return index;
+		}
+	}
+	return -1;
+}
+
+function hasTerminalFailure(events) {
+	const lastCompletedIndex = findLastIndex(
+		events,
+		(event) =>
+			event?.type === "turn.completed" || event?.type === "response.completed",
+	);
 	return (
-		output.includes(token) ||
-		output.includes('"type":"turn.completed"') ||
-		output.includes('"type":"response.completed"')
+		findLastIndex(
+			events,
+			(event, index) =>
+				index > lastCompletedIndex &&
+				(event?.type === "error" ||
+					event?.type === "turn.failed" ||
+					event?.type === "response.failed" ||
+					event?.type === "response.error" ||
+					event?.type === "response.incomplete"),
+		) >= 0
 	);
 }
 
-function getSmokeSkipReason(exitCode, output) {
-	if (exitCode === 124) {
-		return "timed-out";
+function hasCompletedSuccessfully(output, token) {
+	const events = parseNdjsonEvents(output);
+	if (events.length > 0) {
+		if (hasTerminalFailure(events)) {
+			return false;
+		}
+		return events.some(
+			(event) =>
+				event?.type === "turn.completed" ||
+				event?.type === "response.completed",
+		);
 	}
+	return output.includes(token);
+}
+
+function getCapabilitySkipReason(exitCode, output, smoke) {
 	if (/not supported when using codex with a chatgpt account/i.test(output)) {
 		return "unsupported-model";
 	}
@@ -192,14 +251,26 @@ function getSmokeSkipReason(exitCode, output) {
 	) {
 		return "unsupported-reasoning";
 	}
+	if (smoke && exitCode === 124) {
+		return "timed-out";
+	}
 	return null;
 }
 
-function finalizeModelCaseResult(caseInfo, exitCode, output, token, smoke) {
+function finalizeModelCaseResult(
+	caseInfo,
+	exitCode,
+	output,
+	token,
+	{ smoke, strictCapabilities } = {},
+) {
 	const hasToken = output.includes(token);
 	const completed = hasCompletedSuccessfully(output, token);
 	const ok = exitCode === 0 && completed;
-	const skipReason = !ok && smoke ? getSmokeSkipReason(exitCode, output) : null;
+	const skipReason =
+		!ok && strictCapabilities !== true
+			? getCapabilitySkipReason(exitCode, output, smoke === true)
+			: null;
 
 	return {
 		...caseInfo,
@@ -219,8 +290,12 @@ export function __finalizeModelCaseResultForTests(
 	output,
 	token,
 	smoke = false,
+	strictCapabilities = false,
 ) {
-	return finalizeModelCaseResult(caseInfo, exitCode, output, token, smoke);
+	return finalizeModelCaseResult(caseInfo, exitCode, output, token, {
+		smoke,
+		strictCapabilities,
+	});
 }
 
 function stopCodexServersInternal() {
@@ -228,7 +303,7 @@ function stopCodexServersInternal() {
 	spawnedCodexPids.clear();
 	for (const pid of tracked) {
 		if (process.platform === "win32") {
-			runQuiet("taskkill", ["/F", "/T", "/PID", String(pid)]);
+			runQuietWindowsTaskkill(pid);
 			continue;
 		}
 		runQuiet("kill", ["-9", String(pid)]);
@@ -352,7 +427,10 @@ function executeModelCase(caseInfo, index) {
 			124,
 			`Timed out after ${timeoutMs}ms`,
 			token,
-			caseInfo.smoke === true,
+			{
+				smoke: caseInfo.smoke === true,
+				strictCapabilities: caseInfo.strictCapabilities === true,
+			},
 		);
 	}
 
@@ -364,7 +442,10 @@ function executeModelCase(caseInfo, index) {
 		exitCode,
 		combinedOutput,
 		token,
-		caseInfo.smoke === true,
+		{
+			smoke: caseInfo.smoke === true,
+			strictCapabilities: caseInfo.strictCapabilities === true,
+		},
 	);
 }
 
@@ -442,6 +523,7 @@ async function runScenario(scenario, options) {
 		(caseInfo) => ({
 			...caseInfo,
 			smoke: options.smoke,
+			strictCapabilities: options.strictCapabilities,
 		}),
 	);
 	console.log(`\n=== ${scenario.toUpperCase()} (${cases.length} cases) ===`);
@@ -483,6 +565,7 @@ async function main() {
 	const scenarioValue =
 		parseArgValue(args, "--scenario") ?? (smoke ? "modern" : "all");
 	const pluginMode = parseArgValue(args, "--plugin") ?? "dist";
+	const strictCapabilities = args.includes("--strict-capabilities");
 	const noRestore = args.includes("--no-restore");
 	const maxCasesRaw = parseArgValue(args, "--max-cases");
 	const maxCases = maxCasesRaw ? Number.parseInt(maxCasesRaw, 10) : 0;
@@ -530,6 +613,7 @@ async function main() {
 				smoke,
 				maxCases,
 				pluginRef,
+				strictCapabilities,
 			});
 			allResults.push(
 				...scenarioResults.map((item) => ({ ...item, scenario })),