codex-multi-auth 0.1.0 → 0.1.2

package/dist/lib/storage.js

@@ -5,7 +5,7 @@ import { ACCOUNT_LIMITS } from "./constants.js";
 import { createLogger } from "./logger.js";
 import { MODEL_FAMILIES } from "./prompts/codex.js";
 import { AnyAccountStorageSchema, getValidationErrors } from "./schemas.js";
-import { getConfigDir, getProjectConfigDir, getProjectGlobalConfigDir, findProjectRoot, resolvePath } from "./storage/paths.js";
+import { getConfigDir, getProjectConfigDir, getProjectGlobalConfigDir, findProjectRoot, resolvePath, resolveProjectStorageIdentityRoot, } from "./storage/paths.js";
 import { migrateV1ToV3, } from "./storage/migrations.js";
 const log = createLogger("storage");
 const ACCOUNTS_FILE_NAME = "openai-codex-accounts.json";
@@ -13,6 +13,7 @@ const FLAGGED_ACCOUNTS_FILE_NAME = "openai-codex-flagged-accounts.json";
 const LEGACY_FLAGGED_ACCOUNTS_FILE_NAME = "openai-codex-blocked-accounts.json";
 const ACCOUNTS_BACKUP_SUFFIX = ".bak";
 const ACCOUNTS_WAL_SUFFIX = ".wal";
+const ACCOUNTS_BACKUP_HISTORY_DEPTH = 3;
 const BACKUP_COPY_MAX_ATTEMPTS = 5;
 const BACKUP_COPY_BASE_DELAY_MS = 10;
 let storageBackupEnabled = true;
@@ -95,6 +96,7 @@ async function ensureGitignore(storagePath) {
 }
 let currentStoragePath = null;
 let currentLegacyProjectStoragePath = null;
+let currentLegacyWorktreeStoragePath = null;
 let currentProjectRoot = null;
 export function setStorageBackupEnabled(enabled) {
     storageBackupEnabled = enabled;
@@ -102,9 +104,156 @@ export function setStorageBackupEnabled(enabled) {
 function getAccountsBackupPath(path) {
     return `${path}${ACCOUNTS_BACKUP_SUFFIX}`;
 }
+function getAccountsBackupPathAtIndex(path, index) {
+    if (index <= 0) {
+        return getAccountsBackupPath(path);
+    }
+    return `${path}${ACCOUNTS_BACKUP_SUFFIX}.${index}`;
+}
+function getAccountsBackupRecoveryCandidates(path) {
+    const candidates = [];
+    for (let i = 0; i < ACCOUNTS_BACKUP_HISTORY_DEPTH; i += 1) {
+        candidates.push(getAccountsBackupPathAtIndex(path, i));
+    }
+    return candidates;
+}
 function getAccountsWalPath(path) {
     return `${path}${ACCOUNTS_WAL_SUFFIX}`;
 }
+async function copyFileWithRetry(sourcePath, destinationPath, options) {
+    const allowMissingSource = options?.allowMissingSource ?? false;
+    for (let attempt = 0; attempt < BACKUP_COPY_MAX_ATTEMPTS; attempt += 1) {
+        try {
+            await fs.copyFile(sourcePath, destinationPath);
+            return;
+        }
+        catch (error) {
+            const code = error.code;
+            if (allowMissingSource && code === "ENOENT") {
+                return;
+            }
+            const canRetry = (code === "EPERM" || code === "EBUSY") &&
+                attempt + 1 < BACKUP_COPY_MAX_ATTEMPTS;
+            if (canRetry) {
+                await new Promise((resolve) => setTimeout(resolve, BACKUP_COPY_BASE_DELAY_MS * 2 ** attempt));
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+async function renameFileWithRetry(sourcePath, destinationPath) {
+    for (let attempt = 0; attempt < BACKUP_COPY_MAX_ATTEMPTS; attempt += 1) {
+        try {
+            await fs.rename(sourcePath, destinationPath);
+            return;
+        }
+        catch (error) {
+            const code = error.code;
+            const canRetry = (code === "EPERM" || code === "EBUSY" || code === "EAGAIN") &&
+                attempt + 1 < BACKUP_COPY_MAX_ATTEMPTS;
+            if (!canRetry) {
+                throw error;
+            }
+            const jitterMs = Math.floor(Math.random() * BACKUP_COPY_BASE_DELAY_MS);
+            await new Promise((resolve) => setTimeout(resolve, BACKUP_COPY_BASE_DELAY_MS * 2 ** attempt + jitterMs));
+        }
+    }
+}
+async function createRotatingAccountsBackup(path) {
+    const candidates = getAccountsBackupRecoveryCandidates(path);
+    const rotationNonce = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+    const stagedWrites = [];
+    const buildStagedPath = (targetPath, label) => `${targetPath}.rotate.${rotationNonce}.${label}.tmp`;
+    try {
+        for (let i = candidates.length - 1; i > 0; i -= 1) {
+            const previousPath = candidates[i - 1];
+            const currentPath = candidates[i];
+            if (!previousPath || !currentPath || !existsSync(previousPath)) {
+                continue;
+            }
+            const stagedPath = buildStagedPath(currentPath, `slot-${i}`);
+            await copyFileWithRetry(previousPath, stagedPath, { allowMissingSource: true });
+            if (existsSync(stagedPath)) {
+                stagedWrites.push({ targetPath: currentPath, stagedPath });
+            }
+        }
+        const latestBackupPath = candidates[0];
+        if (!latestBackupPath) {
+            return;
+        }
+        const latestStagedPath = buildStagedPath(latestBackupPath, "latest");
+        await copyFileWithRetry(path, latestStagedPath);
+        if (existsSync(latestStagedPath)) {
+            stagedWrites.push({ targetPath: latestBackupPath, stagedPath: latestStagedPath });
+        }
+        for (const stagedWrite of stagedWrites) {
+            await renameFileWithRetry(stagedWrite.stagedPath, stagedWrite.targetPath);
+        }
+    }
+    finally {
+        for (const stagedWrite of stagedWrites) {
+            if (!existsSync(stagedWrite.stagedPath)) {
+                continue;
+            }
+            try {
+                await fs.unlink(stagedWrite.stagedPath);
+            }
+            catch {
+                // Best effort cleanup for staged rotation artifacts.
+            }
+        }
+    }
+}
+function isRotatingBackupTempArtifact(storagePath, candidatePath) {
+    const backupPrefix = `${storagePath}${ACCOUNTS_BACKUP_SUFFIX}`;
+    if (!candidatePath.startsWith(backupPrefix) || !candidatePath.endsWith(".tmp")) {
+        return false;
+    }
+    const suffix = candidatePath.slice(backupPrefix.length);
+    const rotateSeparatorIndex = suffix.indexOf(".rotate.");
+    if (rotateSeparatorIndex === -1) {
+        return false;
+    }
+    const backupIndexSuffix = suffix.slice(0, rotateSeparatorIndex);
+    if (backupIndexSuffix.length > 0 && !/^\.\d+$/.test(backupIndexSuffix)) {
+        return false;
+    }
+    return true;
+}
+async function cleanupStaleRotatingBackupArtifacts(path) {
+    const directoryPath = dirname(path);
+    try {
+        const directoryEntries = await fs.readdir(directoryPath, { withFileTypes: true });
+        const staleArtifacts = directoryEntries
+            .filter((entry) => entry.isFile())
+            .map((entry) => join(directoryPath, entry.name))
+            .filter((entryPath) => isRotatingBackupTempArtifact(path, entryPath));
+        for (const staleArtifactPath of staleArtifacts) {
+            try {
+                await fs.unlink(staleArtifactPath);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== "ENOENT") {
+                    log.warn("Failed to remove stale rotating backup artifact", {
+                        path: staleArtifactPath,
+                        error: String(error),
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT") {
+            log.warn("Failed to scan for stale rotating backup artifacts", {
+                path,
+                error: String(error),
+            });
+        }
+    }
+}
 function computeSha256(value) {
     return createHash("sha256").update(value).digest("hex");
 }
@@ -115,24 +264,31 @@ export function setStoragePath(projectPath) {
     if (!projectPath) {
         currentStoragePath = null;
         currentLegacyProjectStoragePath = null;
+        currentLegacyWorktreeStoragePath = null;
         currentProjectRoot = null;
         return;
     }
     const projectRoot = findProjectRoot(projectPath);
     if (projectRoot) {
         currentProjectRoot = projectRoot;
-        currentStoragePath = join(getProjectGlobalConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
+        const identityRoot = resolveProjectStorageIdentityRoot(projectRoot);
+        currentStoragePath = join(getProjectGlobalConfigDir(identityRoot), ACCOUNTS_FILE_NAME);
         currentLegacyProjectStoragePath = join(getProjectConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
+        const previousWorktreeScopedPath = join(getProjectGlobalConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
+        currentLegacyWorktreeStoragePath =
+            previousWorktreeScopedPath !== currentStoragePath ? previousWorktreeScopedPath : null;
     }
     else {
         currentStoragePath = null;
         currentLegacyProjectStoragePath = null;
+        currentLegacyWorktreeStoragePath = null;
         currentProjectRoot = null;
     }
 }
 export function setStoragePathDirect(path) {
     currentStoragePath = path;
     currentLegacyProjectStoragePath = null;
+    currentLegacyWorktreeStoragePath = null;
     currentProjectRoot = null;
 }
 /**
@@ -152,50 +308,108 @@ function getLegacyFlaggedAccountsPath() {
     return join(dirname(getStoragePath()), LEGACY_FLAGGED_ACCOUNTS_FILE_NAME);
 }
 async function migrateLegacyProjectStorageIfNeeded(persist = saveAccounts) {
-    if (!currentStoragePath ||
-        !currentLegacyProjectStoragePath ||
-        currentLegacyProjectStoragePath === currentStoragePath ||
-        !existsSync(currentLegacyProjectStoragePath)) {
+    if (!currentStoragePath) {
         return null;
     }
-    try {
-        const legacyContent = await fs.readFile(currentLegacyProjectStoragePath, "utf-8");
-        const legacyData = JSON.parse(legacyContent);
-        const normalized = normalizeAccountStorage(legacyData);
-        if (!normalized)
-            return null;
-        await persist(normalized);
+    const candidatePaths = [currentLegacyWorktreeStoragePath, currentLegacyProjectStoragePath]
+        .filter((path) => typeof path === "string" && path.length > 0 && path !== currentStoragePath)
+        .filter((path, index, all) => all.indexOf(path) === index);
+    if (candidatePaths.length === 0) {
+        return null;
+    }
+    const existingCandidatePaths = candidatePaths.filter((legacyPath) => existsSync(legacyPath));
+    if (existingCandidatePaths.length === 0) {
+        return null;
+    }
+    let targetStorage = await loadNormalizedStorageFromPath(currentStoragePath, "current account storage");
+    let migrated = false;
+    for (const legacyPath of existingCandidatePaths) {
+        const legacyStorage = await loadNormalizedStorageFromPath(legacyPath, "legacy account storage");
+        if (!legacyStorage) {
+            continue;
+        }
+        const mergedStorage = mergeStorageForMigration(targetStorage, legacyStorage);
+        const fallbackStorage = targetStorage ?? legacyStorage;
+        try {
+            await persist(mergedStorage);
+            targetStorage = mergedStorage;
+            migrated = true;
+        }
+        catch (error) {
+            targetStorage = fallbackStorage;
+            log.warn("Failed to persist migrated account storage", {
+                from: legacyPath,
+                to: currentStoragePath,
+                error: String(error),
+            });
+            continue;
+        }
         try {
-            await fs.unlink(currentLegacyProjectStoragePath);
-            log.info("Removed legacy project account storage file after migration", {
-                path: currentLegacyProjectStoragePath,
+            await fs.unlink(legacyPath);
+            log.info("Removed legacy account storage file after migration", {
+                path: legacyPath,
             });
         }
         catch (unlinkError) {
             const code = unlinkError.code;
             if (code !== "ENOENT") {
-                log.warn("Failed to remove legacy project account storage file after migration", {
-                    path: currentLegacyProjectStoragePath,
+                log.warn("Failed to remove legacy account storage file after migration", {
+                    path: legacyPath,
                     error: String(unlinkError),
                 });
             }
         }
         log.info("Migrated legacy project account storage", {
-            from: currentLegacyProjectStoragePath,
+            from: legacyPath,
             to: currentStoragePath,
-            accounts: normalized.accounts.length,
+            accounts: mergedStorage.accounts.length,
         });
+    }
+    if (migrated) {
+        return targetStorage;
+    }
+    if (targetStorage && !existsSync(currentStoragePath)) {
+        return targetStorage;
+    }
+    return null;
+}
+async function loadNormalizedStorageFromPath(path, label) {
+    try {
+        const { normalized, schemaErrors } = await loadAccountsFromPath(path);
+        if (schemaErrors.length > 0) {
+            log.warn(`${label} schema validation warnings`, {
+                path,
+                errors: schemaErrors.slice(0, 5),
+            });
+        }
         return normalized;
     }
     catch (error) {
-        log.warn("Failed to migrate legacy project account storage", {
-            from: currentLegacyProjectStoragePath,
-            to: currentStoragePath,
-            error: String(error),
-        });
+        const code = error.code;
+        if (code !== "ENOENT") {
+            log.warn(`Failed to load ${label}`, {
+                path,
+                error: String(error),
+            });
+        }
         return null;
     }
 }
+function mergeStorageForMigration(current, incoming) {
+    if (!current) {
+        return incoming;
+    }
+    const merged = normalizeAccountStorage({
+        version: 3,
+        activeIndex: current.activeIndex,
+        activeIndexByFamily: current.activeIndexByFamily,
+        accounts: [...current.accounts, ...incoming.accounts],
+    });
+    if (!merged) {
+        return current;
+    }
+    return merged;
+}
 function selectNewestAccount(current, candidate) {
     if (!current)
         return candidate;
@@ -256,6 +470,14 @@ export function deduplicateAccounts(accounts) {
  * @param accounts - Array of accounts to deduplicate
  * @returns New array with email duplicates removed
  */
+export function normalizeEmailKey(email) {
+    if (!email)
+        return undefined;
+    const trimmed = email.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.toLowerCase();
+}
 export function deduplicateAccountsByEmail(accounts) {
     const emailToNewestIndex = new Map();
     const indicesToKeep = new Set();
@@ -263,7 +485,7 @@ export function deduplicateAccountsByEmail(accounts) {
         const account = accounts[i];
         if (!account)
             continue;
-        const email = account.email?.trim();
+        const email = normalizeEmailKey(account.email);
         if (!email) {
             indicesToKeep.add(i);
             continue;
@@ -447,8 +669,12 @@ async function loadAccountsFromJournal(path) {
     }
 }
 async function loadAccountsInternal(persistMigration) {
+    const path = getStoragePath();
+    await cleanupStaleRotatingBackupArtifacts(path);
+    const migratedLegacyStorage = persistMigration
+        ? await migrateLegacyProjectStorageIfNeeded(persistMigration)
+        : null;
     try {
-        const path = getStoragePath();
         const { normalized, storedVersion, schemaErrors } = await loadAccountsFromPath(path);
         if (schemaErrors.length > 0) {
             log.warn("Account storage schema validation warnings", { errors: schemaErrors.slice(0, 5) });
@@ -468,11 +694,8 @@ async function loadAccountsInternal(persistMigration) {
     }
     catch (error) {
         const code = error.code;
-        const path = getStoragePath();
-        if (code === "ENOENT" && persistMigration) {
-            const migrated = await migrateLegacyProjectStorageIfNeeded(persistMigration);
-            if (migrated)
-                return migrated;
+        if (code === "ENOENT" && migratedLegacyStorage) {
+            return migratedLegacyStorage;
         }
         const recoveredFromWal = await loadAccountsFromJournal(path);
         if (recoveredFromWal) {
@@ -490,38 +713,40 @@ async function loadAccountsInternal(persistMigration) {
             return recoveredFromWal;
         }
         if (storageBackupEnabled) {
-            const backupPath = getAccountsBackupPath(path);
-            try {
-                const backup = await loadAccountsFromPath(backupPath);
-                if (backup.schemaErrors.length > 0) {
-                    log.warn("Backup account storage schema validation warnings", {
-                        path: backupPath,
-                        errors: backup.schemaErrors.slice(0, 5),
-                    });
-                }
-                if (backup.normalized) {
-                    log.warn("Recovered account storage from backup file", { path, backupPath });
-                    if (persistMigration) {
-                        try {
-                            await persistMigration(backup.normalized);
-                        }
-                        catch (persistError) {
-                            log.warn("Failed to persist recovered backup storage", {
-                                path,
-                                error: String(persistError),
-                            });
+            const backupCandidates = getAccountsBackupRecoveryCandidates(path);
+            for (const backupPath of backupCandidates) {
+                try {
+                    const backup = await loadAccountsFromPath(backupPath);
+                    if (backup.schemaErrors.length > 0) {
+                        log.warn("Backup account storage schema validation warnings", {
+                            path: backupPath,
+                            errors: backup.schemaErrors.slice(0, 5),
+                        });
+                    }
+                    if (backup.normalized) {
+                        log.warn("Recovered account storage from backup file", { path, backupPath });
+                        if (persistMigration) {
+                            try {
+                                await persistMigration(backup.normalized);
+                            }
+                            catch (persistError) {
+                                log.warn("Failed to persist recovered backup storage", {
+                                    path,
+                                    error: String(persistError),
+                                });
+                            }
                         }
+                        return backup.normalized;
                     }
-                    return backup.normalized;
                 }
-            }
-            catch (backupError) {
-                const backupCode = backupError.code;
-                if (backupCode !== "ENOENT") {
-                    log.warn("Failed to load backup account storage", {
-                        path: backupPath,
-                        error: String(backupError),
-                    });
+                catch (backupError) {
+                    const backupCode = backupError.code;
+                    if (backupCode !== "ENOENT") {
+                        log.warn("Failed to load backup account storage", {
+                            path: backupPath,
+                            error: String(backupError),
+                        });
+                    }
                 }
             }
         }
@@ -540,29 +765,13 @@ async function saveAccountsUnlocked(storage) {
         await fs.mkdir(dirname(path), { recursive: true });
         await ensureGitignore(path);
         if (storageBackupEnabled && existsSync(path)) {
-            const backupPath = getAccountsBackupPath(path);
             try {
-                for (let attempt = 0; attempt < BACKUP_COPY_MAX_ATTEMPTS; attempt += 1) {
-                    try {
-                        await fs.copyFile(path, backupPath);
-                        break;
-                    }
-                    catch (backupError) {
-                        const code = backupError.code;
-                        const canRetry = (code === "EPERM" || code === "EBUSY") &&
-                            attempt + 1 < BACKUP_COPY_MAX_ATTEMPTS;
-                        if (canRetry) {
-                            await new Promise((resolve) => setTimeout(resolve, BACKUP_COPY_BASE_DELAY_MS * 2 ** attempt));
-                            continue;
-                        }
-                        throw backupError;
-                    }
-                }
+                await createRotatingAccountsBackup(path);
             }
             catch (backupError) {
                 log.warn("Failed to create account storage backup", {
                     path,
-                    backupPath,
+                    backupPath: getAccountsBackupPath(path),
                     error: String(backupError),
                 });
             }
@@ -657,7 +866,7 @@ export async function clearAccounts() {
     return withStorageLock(async () => {
         const path = getStoragePath();
         const walPath = getAccountsWalPath(path);
-        const backupPath = getAccountsBackupPath(path);
+        const backupPaths = getAccountsBackupRecoveryCandidates(path);
         const clearPath = async (targetPath) => {
             try {
                 await fs.unlink(targetPath);
@@ -673,7 +882,7 @@ export async function clearAccounts() {
             }
         };
         try {
-            await Promise.all([clearPath(path), clearPath(walPath), clearPath(backupPath)]);
+            await Promise.all([clearPath(path), clearPath(walPath), ...backupPaths.map(clearPath)]);
         }
         catch {
             // Individual path cleanup is already best-effort with per-artifact logging.