codex-multi-auth 0.1.2 → 0.1.4

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;
@@ -156,5 +210,7 @@ if (!realCodexBin) {
 	process.exit(1);
 }
 
-const forwardExitCode = await forwardToRealCodex(realCodexBin, rawArgs);
+await autoSyncManagerActiveSelectionIfEnabled();
+const forwardArgs = buildForwardArgs(rawArgs);
+const forwardExitCode = await forwardToRealCodex(realCodexBin, forwardArgs);
 process.exit(forwardExitCode);

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}).`);
+			}
 		}
 	}
 }
@@ -136,8 +145,8 @@ async function clearCache() {
 		log(`[dry-run] Would remove ${cacheBunLock}`);
 	} else {
 		try {
-			await rm(cacheNodeModules, { recursive: true, force: true });
-			await rm(cacheBunLock, { force: true });
+			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.`,