codex-multi-auth 0.1.3 → 0.1.5

package/scripts/benchmark-runtime-path.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { performance } from "node:perf_hooks";
+import process from "node:process";
+import { dirname, resolve } from "node:path";
+import { filterInput } from "../dist/lib/request/request-transformer.js";
+import { cleanupToolDefinitions } from "../dist/lib/request/helpers/tool-utils.js";
+import { AccountManager } from "../dist/lib/accounts.js";
+
+function argValue(args, name) {
+	const prefix = `${name}=`;
+	const match = args.find((arg) => arg.startsWith(prefix));
+	return match ? match.slice(prefix.length) : undefined;
+}
+
+function parsePositiveInt(value, fallback) {
+	if (!value) return fallback;
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+	return parsed;
+}
+
+function benchmarkCase(name, iterations, fn) {
+	for (let i = 0; i < 5; i += 1) {
+		fn();
+	}
+	const start = performance.now();
+	for (let i = 0; i < iterations; i += 1) {
+		fn();
+	}
+	const end = performance.now();
+	return {
+		name,
+		iterations,
+		avgMs: Number(((end - start) / iterations).toFixed(6)),
+	};
+}
+
+function buildInputItems(size) {
+	const items = [];
+	for (let i = 0; i < size; i += 1) {
+		items.push({
+			type: "message",
+			role: i % 2 === 0 ? "user" : "assistant",
+			id: `msg_${i}`,
+			content: [{ type: "input_text", text: `payload-${i}` }],
+		});
+		if (i % 40 === 0) {
+			items.push({ type: "item_reference", id: `ref_${i}` });
+		}
+	}
+	return items;
+}
+
+function buildTools(toolCount, propertyCount) {
+	const tools = [];
+	for (let i = 0; i < toolCount; i += 1) {
+		const properties = {};
+		const required = [];
+		for (let j = 0; j < propertyCount; j += 1) {
+			const key = `field_${j}`;
+			properties[key] = { type: ["string", "null"], description: `property-${j}` };
+			required.push(key);
+		}
+		required.push("ghost_field");
+		tools.push({
+			type: "function",
+			function: {
+				name: `tool_${i}`,
+				parameters: {
+					type: "object",
+					properties,
+					required,
+					additionalProperties: false,
+				},
+			},
+		});
+	}
+	return tools;
+}
+
+function buildManager(accountCount) {
+	const now = Date.now();
+	const accounts = [];
+	for (let i = 0; i < accountCount; i += 1) {
+		accounts.push({
+			refreshToken: `rt_${i}`,
+			accessToken: `at_${i}`,
+			expiresAt: now + 3_600_000,
+			accountId: `acct_${i}`,
+			email: `user${i}@example.com`,
+			enabled: true,
+			addedAt: now,
+			lastUsed: 0,
+			rateLimitResetTimes: {},
+		});
+	}
+	return new AccountManager(undefined, {
+		version: 3,
+		accounts,
+		activeIndex: 0,
+		activeIndexByFamily: {},
+	});
+}
+
+function run() {
+	const args = process.argv.slice(2);
+	const iterations = parsePositiveInt(argValue(args, "--iterations"), 30);
+	const outputPath = argValue(args, "--output");
+
+	const inputSmall = buildInputItems(400);
+	const inputLarge = buildInputItems(2000);
+	const toolsMedium = buildTools(40, 12);
+	const toolsLarge = buildTools(140, 25);
+
+	const results = [
+		benchmarkCase("filterInput_small", iterations, () => {
+			const out = filterInput(inputSmall);
+			if (!Array.isArray(out)) throw new Error("filterInput_small failed");
+		}),
+		benchmarkCase("filterInput_large", iterations, () => {
+			const out = filterInput(inputLarge);
+			if (!Array.isArray(out)) throw new Error("filterInput_large failed");
+		}),
+		benchmarkCase("cleanupToolDefinitions_medium", iterations, () => {
+			const out = cleanupToolDefinitions(toolsMedium);
+			if (!Array.isArray(out)) throw new Error("cleanupToolDefinitions_medium failed");
+		}),
+		benchmarkCase("cleanupToolDefinitions_large", iterations, () => {
+			const out = cleanupToolDefinitions(toolsLarge);
+			if (!Array.isArray(out)) throw new Error("cleanupToolDefinitions_large failed");
+		}),
+		benchmarkCase("accountHybridSelection_200", iterations, () => {
+			const manager = buildManager(200);
+			for (let i = 0; i < 200; i += 1) {
+				manager.getCurrentOrNextForFamilyHybrid("codex", "gpt-5-codex", { pidOffsetEnabled: false });
+			}
+		}),
+	];
+
+	const payload = {
+		generatedAt: new Date().toISOString(),
+		node: process.version,
+		iterations,
+		results,
+	};
+
+	if (outputPath) {
+		const resolved = resolve(outputPath);
+		return mkdir(dirname(resolved), { recursive: true }).then(() =>
+			writeFile(resolved, `${JSON.stringify(payload, null, 2)}\n`, "utf8"),
+		).then(() => {
+			console.log(`Runtime benchmark written: ${resolved}`);
+			console.log(JSON.stringify(payload, null, 2));
+		});
+	}
+
+	console.log(JSON.stringify(payload, null, 2));
+	return Promise.resolve();
+}
+
+run().catch((error) => {
+	console.error(`Runtime benchmark failed: ${error instanceof Error ? error.message : String(error)}`);
+	process.exit(1);
+});

package/scripts/codex-multi-auth.js

@@ -3,4 +3,4 @@
 import { runCodexMultiAuthCli } from "../dist/lib/codex-manager.js";
 
 const exitCode = await runCodexMultiAuthCli(process.argv.slice(2));
-process.exit(exitCode);
+process.exitCode = Number.isInteger(exitCode) ? exitCode : 1;

package/scripts/codex.js

@@ -32,6 +32,25 @@ async function loadRunCodexMultiAuthCli() {
 	}
 }
 
+async function autoSyncManagerActiveSelectionIfEnabled() {
+	const enabled = (process.env.CODEX_MULTI_AUTH_AUTO_SYNC_ON_STARTUP ?? "1").trim() !== "0";
+	if (!enabled) return;
+
+	try {
+		const mod = await import("../dist/lib/codex-manager.js");
+		if (typeof mod.autoSyncActiveAccountToCodex !== "function") {
+			return;
+		}
+		await mod.autoSyncActiveAccountToCodex();
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ERR_MODULE_NOT_FOUND") {
+			// Non-auth command path should keep forwarding even if dist is missing.
+			return;
+		}
+		// Best effort only: never block official Codex startup on sync failure.
+	}
+}
+
 function resolveRealCodexBin() {
 	const override = (process.env.CODEX_MULTI_AUTH_REAL_CODEX_BIN ?? "").trim();
 	if (override.length > 0) {
@@ -113,6 +132,41 @@ function forwardToRealCodex(codexBin, args) {
 	});
 }
 
+function hasCliAuthCredentialsStoreOverride(args) {
+	for (let i = 0; i < args.length; i += 1) {
+		const arg = args[i];
+		if (arg === "-c" || arg === "--config") {
+			const next = args[i + 1];
+			if (!next || !next.includes("=")) continue;
+			const [key] = next.split("=", 1);
+			if ((key ?? "").trim() === "cli_auth_credentials_store") {
+				return true;
+			}
+			continue;
+		}
+		if (typeof arg === "string" && arg.startsWith("--config=")) {
+			const assignment = arg.slice("--config=".length);
+			const [key] = assignment.split("=", 1);
+			if ((key ?? "").trim() === "cli_auth_credentials_store") {
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+function buildForwardArgs(rawArgs) {
+	const forceFileAuthStore = (process.env.CODEX_MULTI_AUTH_FORCE_FILE_AUTH_STORE ?? "1").trim() !== "0";
+	if (!forceFileAuthStore) return [...rawArgs];
+	if (hasCliAuthCredentialsStoreOverride(rawArgs)) return [...rawArgs];
+
+	return [
+		...rawArgs,
+		"-c",
+		'cli_auth_credentials_store="file"',
+	];
+}
+
 function normalizeExitCode(value) {
 	if (typeof value === "number" && Number.isInteger(value)) {
 		return value;
@@ -124,37 +178,43 @@ function normalizeExitCode(value) {
 	return 1;
 }
 
-const rawArgs = process.argv.slice(2);
-const normalizedArgs = normalizeAuthAlias(rawArgs);
-const bypass = (process.env.CODEX_MULTI_AUTH_BYPASS ?? "").trim() === "1";
+async function main() {
+	const rawArgs = process.argv.slice(2);
+	const normalizedArgs = normalizeAuthAlias(rawArgs);
+	const bypass = (process.env.CODEX_MULTI_AUTH_BYPASS ?? "").trim() === "1";
 
-if (!bypass && shouldHandleMultiAuthAuth(normalizedArgs)) {
-	try {
-		const runCodexMultiAuthCli = await loadRunCodexMultiAuthCli();
-		if (!runCodexMultiAuthCli) {
-			process.exit(1);
+	if (!bypass && shouldHandleMultiAuthAuth(normalizedArgs)) {
+		try {
+			const runCodexMultiAuthCli = await loadRunCodexMultiAuthCli();
+			if (!runCodexMultiAuthCli) {
+				return 1;
+			}
+			const exitCode = await runCodexMultiAuthCli(normalizedArgs);
+			return normalizeExitCode(exitCode);
+		} catch (error) {
+			console.error(
+				`codex-multi-auth runner failed: ${error instanceof Error ? error.message : String(error)}`,
+			);
+			return 1;
 		}
-		const exitCode = await runCodexMultiAuthCli(normalizedArgs);
-		process.exit(normalizeExitCode(exitCode));
-	} catch (error) {
+	}
+
+	const realCodexBin = resolveRealCodexBin();
+	if (!realCodexBin) {
 		console.error(
-			`codex-multi-auth runner failed: ${error instanceof Error ? error.message : String(error)}`,
+			[
+				"Could not locate the official Codex CLI binary (@openai/codex).",
+				"Install it globally: npm install -g @openai/codex",
+				"Or set CODEX_MULTI_AUTH_REAL_CODEX_BIN to a full bin/codex.js path.",
+			].join("\n"),
 		);
-		process.exit(1);
+		return 1;
 	}
-}
 
-const realCodexBin = resolveRealCodexBin();
-if (!realCodexBin) {
-	console.error(
-		[
-			"Could not locate the official Codex CLI binary (@openai/codex).",
-			"Install it globally: npm install -g @openai/codex",
-			"Or set CODEX_MULTI_AUTH_REAL_CODEX_BIN to a full bin/codex.js path.",
-		].join("\n"),
-	);
-	process.exit(1);
+	await autoSyncManagerActiveSelectionIfEnabled();
+	const forwardArgs = buildForwardArgs(rawArgs);
+	return forwardToRealCodex(realCodexBin, forwardArgs);
 }
 
-const forwardExitCode = await forwardToRealCodex(realCodexBin, rawArgs);
-process.exit(forwardExitCode);
+const exitCode = await main();
+process.exitCode = normalizeExitCode(exitCode);

package/scripts/copy-oauth-success.js

@@ -1,4 +1,4 @@
-import { promises as fs } from "node:fs";
+import * as fs from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -16,20 +16,59 @@ function getDefaultPaths() {
 	return { src, dest };
 }
 
+/**
+ * Copy a file and retry automatically while the destination is temporarily locked.
+ * @param {string} src absolute path to the source HTML file
+ * @param {string} dest absolute path to the destination HTML file
+ * @param {{ maxAttempts?: number, backoffMs?: number }} options retry configuration
+ */
+async function copyWithRetry(
+	src,
+	dest,
+	{ maxAttempts = 3, backoffMs = 50 } = {},
+) {
+	const retryableCodes = new Set(["EBUSY", "EPERM", "EACCES"]);
+	let attempt = 0;
+	for (;;) {
+		try {
+			await fs.copyFile(src, dest);
+			return;
+		} catch (err) {
+			const code = err && typeof err === "object" && "code" in err ? err.code : undefined;
+			const isRetryable = typeof code === "string" && retryableCodes.has(code);
+			if (!isRetryable || attempt >= maxAttempts - 1) {
+				throw err;
+			}
+			attempt += 1;
+			const delayMs = backoffMs * (2 ** (attempt - 1));
+			await new Promise((resolve) => {
+				setTimeout(resolve, delayMs);
+			});
+		}
+	}
+}
+
+/**
+ * Copy the OAuth success HTML into dist/, ensuring safe directory creation and retries.
+ * @param {{ src?: string, dest?: string }} options optional override paths for testing
+ */
 export async function copyOAuthSuccessHtml(options = {}) {
 	const defaults = getDefaultPaths();
 	const src = options.src ?? defaults.src;
 	const dest = options.dest ?? defaults.dest;
 
 	await fs.mkdir(dirname(dest), { recursive: true });
-	await fs.copyFile(src, dest);
+	await copyWithRetry(src, dest);
 
 	return { src, dest };
 }
 
 const isDirectRun = (() => {
 	if (!process.argv[1]) return false;
-	return normalizePathForCompare(process.argv[1]) === normalizePathForCompare(__filename);
+	return (
+		normalizePathForCompare(process.argv[1]) ===
+		normalizePathForCompare(__filename)
+	);
 })();
 
 if (isDirectRun) {

package/scripts/install-codex-auth-utils.js

@@ -1,7 +1,12 @@
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { rename as fsRename } from "node:fs/promises";
 
 const PLUGIN_NAME = "codex-multi-auth";
+export const FILE_RETRY_CODES = new Set(["EBUSY", "EPERM", "EAGAIN", "ENOTEMPTY", "EACCES"]);
+export const FILE_RETRY_MAX_ATTEMPTS = 6;
+export const FILE_RETRY_BASE_DELAY_MS = 25;
+export const FILE_RETRY_JITTER_MS = 20;
 
 export function resolveInstallPaths(
 	platform = process.platform,
@@ -47,3 +52,67 @@ export function normalizePluginList(list) {
 	return [...deduped, PLUGIN_NAME];
 }
 
+function sleep(ms) {
+	// Keep this helper local so installer scripts remain standalone and do not depend on lib/.
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+
+function shouldRetryFileOperation(error) {
+	return error instanceof Error &&
+		typeof error.code === "string" &&
+		FILE_RETRY_CODES.has(error.code);
+}
+
+export async function withFileOperationRetry(operation) {
+	for (let attempt = 1; ; attempt += 1) {
+		try {
+			return await operation();
+		} catch (error) {
+			if (!shouldRetryFileOperation(error) || attempt >= FILE_RETRY_MAX_ATTEMPTS) {
+				throw error;
+			}
+
+			const jitter = Math.floor(Math.random() * FILE_RETRY_JITTER_MS);
+			const delayMs = (FILE_RETRY_BASE_DELAY_MS * (2 ** (attempt - 1))) + jitter;
+			await sleep(delayMs);
+		}
+	}
+}
+
+export async function renameWithRetry(sourcePath, targetPath, options = {}) {
+	const {
+		rename = fsRename,
+		log = () => {},
+		maxRetries = FILE_RETRY_MAX_ATTEMPTS,
+		baseDelayMs = FILE_RETRY_BASE_DELAY_MS,
+		jitterMs = FILE_RETRY_JITTER_MS,
+		random = Math.random,
+		sleep: sleepImpl = sleep,
+	} = options;
+
+	if (!Number.isInteger(maxRetries) || maxRetries < 1) {
+		throw new RangeError("maxRetries must be an integer >= 1");
+	}
+
+	for (let attempt = 0; attempt < maxRetries; attempt += 1) {
+		try {
+			await rename(sourcePath, targetPath);
+			return;
+		} catch (error) {
+			const code = error && typeof error === "object" && "code" in error
+				? error.code
+				: undefined;
+			const isRetryable = typeof code === "string" && FILE_RETRY_CODES.has(code);
+			if (!isRetryable || attempt === maxRetries - 1) {
+				throw error;
+			}
+			const delayMs = baseDelayMs * 2 ** attempt + Math.floor(random() * jitterMs);
+			log(
+				`Retrying atomic rename (${attempt + 1}/${maxRetries}) code=${code ?? "unknown"} source=${sourcePath} target=${targetPath} delayMs=${delayMs}`,
+			);
+			await sleepImpl(delayMs);
+		}
+	}
+}

package/scripts/install-codex-auth.js

@@ -1,10 +1,15 @@
 #!/usr/bin/env node
 
 import { existsSync } from "node:fs";
-import { readFile, writeFile, mkdir, copyFile, rm, rename } from "node:fs/promises";
+import { readFile, writeFile, mkdir, copyFile, rm } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { dirname, join, resolve } from "node:path";
-import { normalizePluginList, resolveInstallPaths } from "./install-codex-auth-utils.js";
+import {
+	normalizePluginList,
+	renameWithRetry,
+	resolveInstallPaths,
+	withFileOperationRetry,
+} from "./install-codex-auth-utils.js";
 
 const PLUGIN_NAME = "codex-multi-auth";
 
@@ -61,11 +66,15 @@ async function writeJsonAtomic(filePath, value) {
 		.slice(2, 8)}`;
 	const content = formatJson(value);
 	try {
-		await writeFile(tempPath, content, "utf-8");
-		await rename(tempPath, filePath);
+		await withFileOperationRetry(() => writeFile(tempPath, content, "utf-8"));
+		await renameWithRetry(tempPath, filePath, { log });
 	} finally {
 		if (existsSync(tempPath)) {
-			await rm(tempPath, { force: true });
+			try {
+				await withFileOperationRetry(() => rm(tempPath, { force: true }));
+			} catch (error) {
+				log(`Warning: Could not remove temporary file ${tempPath} (${error}).`);
+			}
 		}
 	}
 }
@@ -134,15 +143,15 @@ async function clearCache() {
 	if (dryRun) {
 		log(`[dry-run] Would remove ${cacheNodeModules}`);
 		log(`[dry-run] Would remove ${cacheBunLock}`);
-	} else {
-		try {
-			await rm(cacheNodeModules, { recursive: true, force: true });
-			await rm(cacheBunLock, { force: true });
-		} catch (error) {
-			log(
-				`Warning: Could not fully clear cache (${error instanceof Error ? error.message : String(error)}). You may need to restart Codex.`,
-			);
-		}
+	} else {
+		try {
+			await withFileOperationRetry(() => rm(cacheNodeModules, { recursive: true, force: true }));
+			await withFileOperationRetry(() => rm(cacheBunLock, { force: true }));
+		} catch (error) {
+			log(
+				`Warning: Could not fully clear cache (${error instanceof Error ? error.message : String(error)}). You may need to restart Codex.`,
+			);
+		}
 	}
 
 	await removePluginFromCachePackage();

package/scripts/test-all-models.sh

@@ -1,7 +1,7 @@
-#!/bin/bash
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-node "${SCRIPT_DIR}/test-model-matrix.js" "$@"
-
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+node "${SCRIPT_DIR}/test-model-matrix.js" "$@"
+