codex-multi-auth 1.1.11 → 1.2.0

package/dist/lib/storage.js

@@ -1,10 +1,10 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash } from "node:crypto";
 import { existsSync, promises as fs } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, isAbsolute, join, relative } from "node:path";
 import { ACCOUNT_LIMITS } from "./constants.js";
 import { createLogger } from "./logger.js";
-import { exportNamedBackupFile, resolveNamedBackupPath, } from "./named-backup-export.js";
+import { exportNamedBackupFile, getNamedBackupRoot, resolveNamedBackupPath, } from "./named-backup-export.js";
 import { MODEL_FAMILIES } from "./prompts/codex.js";
 import { AnyAccountStorageSchema, getValidationErrors } from "./schemas.js";
 import { migrateV1ToV3, } from "./storage/migrations.js";
@@ -21,6 +21,71 @@ const BACKUP_COPY_BASE_DELAY_MS = 10;
 const RESET_MARKER_SUFFIX = ".reset-intent";
 let storageBackupEnabled = true;
 let lastAccountsSaveTimestamp = 0;
+async function collectNamedBackups(storagePath) {
+    const backupRoot = getNamedBackupRoot(storagePath);
+    let entries;
+    try {
+        entries = await fs.readdir(backupRoot, {
+            withFileTypes: true,
+            encoding: "utf8",
+        });
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.toLowerCase().endsWith(".json"))
+            continue;
+        const candidatePath = join(backupRoot, entry.name);
+        try {
+            const statsBefore = await fs.stat(candidatePath);
+            const { normalized } = await loadAccountsFromPath(candidatePath);
+            if (!normalized || normalized.accounts.length === 0)
+                continue;
+            const statsAfter = await fs.stat(candidatePath).catch(() => null);
+            if (statsAfter && statsAfter.mtimeMs !== statsBefore.mtimeMs) {
+                log.debug("backup file changed between stat and load, mtime may be stale", {
+                    candidatePath,
+                    fileName: entry.name,
+                    beforeMtimeMs: statsBefore.mtimeMs,
+                    afterMtimeMs: statsAfter.mtimeMs,
+                });
+            }
+            candidates.push({
+                path: candidatePath,
+                fileName: entry.name,
+                accountCount: normalized.accounts.length,
+                mtimeMs: statsBefore.mtimeMs,
+            });
+        }
+        catch (error) {
+            log.debug("Skipping named backup candidate after loadAccountsFromPath/fs.stat failure", {
+                candidatePath,
+                fileName: entry.name,
+                error: error instanceof Error
+                    ? {
+                        message: error.message,
+                        stack: error.stack,
+                    }
+                    : String(error),
+            });
+            continue;
+        }
+    }
+    candidates.sort((left, right) => {
+        const mtimeDelta = right.mtimeMs - left.mtimeMs;
+        if (mtimeDelta !== 0)
+            return mtimeDelta;
+        return left.fileName.localeCompare(right.fileName);
+    });
+    return candidates;
+}
 /**
  * Custom error class for storage operations with platform-aware hints.
  */
@@ -98,11 +163,12 @@ function looksLikeSyntheticFixtureStorage(storage) {
     return storage.accounts.every((account) => looksLikeSyntheticFixtureAccount(account));
 }
 async function ensureGitignore(storagePath) {
-    if (!currentStoragePath)
+    const state = getStoragePathState();
+    if (!state.currentStoragePath)
         return;
     const configDir = dirname(storagePath);
     const inferredProjectRoot = dirname(configDir);
-    const candidateRoots = [currentProjectRoot, inferredProjectRoot].filter((root) => typeof root === "string" && root.length > 0);
+    const candidateRoots = [state.currentProjectRoot, inferredProjectRoot].filter((root) => typeof root === "string" && root.length > 0);
     const projectRoot = candidateRoots.find((root) => existsSync(join(root, ".git")));
     if (!projectRoot)
         return;
@@ -127,10 +193,20 @@ async function ensureGitignore(storagePath) {
         log.warn("Failed to update .gitignore", { error: String(error) });
     }
 }
-let currentStoragePath = null;
-let currentLegacyProjectStoragePath = null;
-let currentLegacyWorktreeStoragePath = null;
-let currentProjectRoot = null;
+let currentStorageState = {
+    currentStoragePath: null,
+    currentLegacyProjectStoragePath: null,
+    currentLegacyWorktreeStoragePath: null,
+    currentProjectRoot: null,
+};
+const storagePathStateContext = new AsyncLocalStorage();
+function getStoragePathState() {
+    return storagePathStateContext.getStore() ?? currentStorageState;
+}
+function setStoragePathState(state) {
+    currentStorageState = state;
+    storagePathStateContext.enterWith(state);
+}
 export function setStorageBackupEnabled(enabled) {
     storageBackupEnabled = enabled;
 }
@@ -536,50 +612,115 @@ export function getLastAccountsSaveTimestamp() {
 }
 export function setStoragePath(projectPath) {
     if (!projectPath) {
-        currentStoragePath = null;
-        currentLegacyProjectStoragePath = null;
-        currentLegacyWorktreeStoragePath = null;
-        currentProjectRoot = null;
+        setStoragePathState({
+            currentStoragePath: null,
+            currentLegacyProjectStoragePath: null,
+            currentLegacyWorktreeStoragePath: null,
+            currentProjectRoot: null,
+        });
         return;
     }
     const projectRoot = findProjectRoot(projectPath);
     if (projectRoot) {
-        currentProjectRoot = projectRoot;
         const identityRoot = resolveProjectStorageIdentityRoot(projectRoot);
-        currentStoragePath = join(getProjectGlobalConfigDir(identityRoot), ACCOUNTS_FILE_NAME);
-        currentLegacyProjectStoragePath = join(getProjectConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
+        const currentStoragePath = join(getProjectGlobalConfigDir(identityRoot), ACCOUNTS_FILE_NAME);
+        const currentLegacyProjectStoragePath = join(getProjectConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
         const previousWorktreeScopedPath = join(getProjectGlobalConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
-        currentLegacyWorktreeStoragePath =
-            previousWorktreeScopedPath !== currentStoragePath
-                ? previousWorktreeScopedPath
-                : null;
+        const currentLegacyWorktreeStoragePath = previousWorktreeScopedPath !== currentStoragePath
+            ? previousWorktreeScopedPath
+            : null;
+        setStoragePathState({
+            currentStoragePath,
+            currentLegacyProjectStoragePath,
+            currentLegacyWorktreeStoragePath,
+            currentProjectRoot: projectRoot,
+        });
     }
     else {
-        currentStoragePath = null;
-        currentLegacyProjectStoragePath = null;
-        currentLegacyWorktreeStoragePath = null;
-        currentProjectRoot = null;
+        setStoragePathState({
+            currentStoragePath: null,
+            currentLegacyProjectStoragePath: null,
+            currentLegacyWorktreeStoragePath: null,
+            currentProjectRoot: null,
+        });
     }
 }
 export function setStoragePathDirect(path) {
-    currentStoragePath = path;
-    currentLegacyProjectStoragePath = null;
-    currentLegacyWorktreeStoragePath = null;
-    currentProjectRoot = null;
+    setStoragePathState({
+        currentStoragePath: path,
+        currentLegacyProjectStoragePath: null,
+        currentLegacyWorktreeStoragePath: null,
+        currentProjectRoot: null,
+    });
 }
 /**
  * Returns the file path for the account storage JSON file.
  * @returns Absolute path to the accounts.json file
  */
 export function getStoragePath() {
-    if (currentStoragePath) {
-        return currentStoragePath;
+    const state = getStoragePathState();
+    if (state.currentStoragePath) {
+        return state.currentStoragePath;
     }
     return join(getConfigDir(), ACCOUNTS_FILE_NAME);
 }
 export function buildNamedBackupPath(name) {
     return resolveNamedBackupPath(name, getStoragePath());
 }
+export async function getNamedBackups() {
+    return collectNamedBackups(getStoragePath());
+}
+export async function restoreAccountsFromBackup(path, options) {
+    const backupRoot = getNamedBackupRoot(getStoragePath());
+    let resolvedBackupRoot;
+    try {
+        resolvedBackupRoot = await fs.realpath(backupRoot);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            throw new Error(`Backup root does not exist: ${backupRoot}`);
+        }
+        throw error;
+    }
+    let resolvedBackupPath;
+    try {
+        resolvedBackupPath = await fs.realpath(path);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            throw new Error(`Backup file no longer exists: ${path}`);
+        }
+        throw error;
+    }
+    const relativePath = relative(resolvedBackupRoot, resolvedBackupPath);
+    const isInsideBackupRoot = relativePath.length > 0 &&
+        !relativePath.startsWith("..") &&
+        !isAbsolute(relativePath);
+    if (!isInsideBackupRoot) {
+        throw new Error(`Backup path must stay inside ${resolvedBackupRoot}: ${path}`);
+    }
+    const { normalized } = await (async () => {
+        try {
+            return await loadAccountsFromPath(resolvedBackupPath);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT") {
+                throw new Error(`Backup file no longer exists: ${path}`);
+            }
+            throw error;
+        }
+    })();
+    if (!normalized || normalized.accounts.length === 0) {
+        throw new Error(`Backup does not contain any accounts: ${resolvedBackupPath}`);
+    }
+    if (options?.persist !== false) {
+        await saveAccounts(normalized);
+    }
+    return normalized;
+}
 export async function exportNamedBackup(name, options) {
     return exportNamedBackupFile(name, {
         getStoragePath,
@@ -593,16 +734,17 @@ function getLegacyFlaggedAccountsPath() {
     return join(dirname(getStoragePath()), LEGACY_FLAGGED_ACCOUNTS_FILE_NAME);
 }
 async function migrateLegacyProjectStorageIfNeeded(persist = saveAccounts) {
-    if (!currentStoragePath) {
+    const state = getStoragePathState();
+    if (!state.currentStoragePath) {
         return null;
     }
     const candidatePaths = [
-        currentLegacyWorktreeStoragePath,
-        currentLegacyProjectStoragePath,
+        state.currentLegacyWorktreeStoragePath,
+        state.currentLegacyProjectStoragePath,
     ]
         .filter((path) => typeof path === "string" &&
         path.length > 0 &&
-        path !== currentStoragePath)
+        path !== state.currentStoragePath)
         .filter((path, index, all) => all.indexOf(path) === index);
     if (candidatePaths.length === 0) {
         return null;
@@ -611,7 +753,7 @@ async function migrateLegacyProjectStorageIfNeeded(persist = saveAccounts) {
     if (existingCandidatePaths.length === 0) {
         return null;
     }
-    let targetStorage = await loadNormalizedStorageFromPath(currentStoragePath, "current account storage");
+    let targetStorage = await loadNormalizedStorageFromPath(state.currentStoragePath, "current account storage");
     let migrated = false;
     for (const legacyPath of existingCandidatePaths) {
         const legacyStorage = await loadNormalizedStorageFromPath(legacyPath, "legacy account storage");
@@ -629,7 +771,7 @@ async function migrateLegacyProjectStorageIfNeeded(persist = saveAccounts) {
             targetStorage = fallbackStorage;
             log.warn("Failed to persist migrated account storage", {
                 from: legacyPath,
-                to: currentStoragePath,
+                to: state.currentStoragePath,
                 error: String(error),
             });
             continue;
@@ -651,14 +793,14 @@ async function migrateLegacyProjectStorageIfNeeded(persist = saveAccounts) {
         }
         log.info("Migrated legacy project account storage", {
             from: legacyPath,
-            to: currentStoragePath,
+            to: state.currentStoragePath,
             accounts: mergedStorage.accounts.length,
         });
     }
     if (migrated) {
         return targetStorage;
     }
-    if (targetStorage && !existsSync(currentStoragePath)) {
+    if (targetStorage && !existsSync(state.currentStoragePath)) {
         return targetStorage;
     }
     return null;
@@ -1437,8 +1579,10 @@ function cloneAccountStorageForPersistence(storage) {
 }
 export async function withAccountStorageTransaction(handler) {
     return withStorageLock(async () => {
+        const storagePath = getStoragePath();
         const state = {
             snapshot: await loadAccountsInternal(saveAccountsUnlocked),
+            storagePath,
             active: true,
         };
         const current = state.snapshot;
@@ -1451,8 +1595,10 @@ export async function withAccountStorageTransaction(handler) {
 }
 export async function withAccountAndFlaggedStorageTransaction(handler) {
     return withStorageLock(async () => {
+        const storagePath = getStoragePath();
         const state = {
             snapshot: await loadAccountsInternal(saveAccountsUnlocked),
+            storagePath,
             active: true,
         };
         const current = state.snapshot;
@@ -1555,7 +1701,8 @@ function normalizeFlaggedStorage(data) {
         const isSwitchReason = (value) => value === "rate-limit" ||
             value === "initial" ||
             value === "rotation" ||
-            value === "best";
+            value === "best" ||
+            value === "restore";
         const isCooldownReason = (value) => value === "auth-failure" ||
             value === "network-error" ||
             value === "rate-limit";
@@ -1769,13 +1916,17 @@ export async function clearFlaggedAccounts() {
  */
 export async function exportAccounts(filePath, force = true, beforeCommit) {
     const resolvedPath = resolvePath(filePath);
+    const currentStoragePath = getStoragePath();
     if (!force && existsSync(resolvedPath)) {
         throw new Error(`File already exists: ${resolvedPath}`);
     }
     const transactionState = transactionSnapshotContext.getStore();
-    const storage = transactionState?.active
+    const storage = transactionState?.active &&
+        transactionState.storagePath === currentStoragePath
         ? transactionState.snapshot
-        : await withAccountStorageTransaction((current) => Promise.resolve(current));
+        : transactionState?.active
+            ? await loadAccountsInternal(saveAccountsUnlocked)
+            : await withAccountStorageTransaction((current) => Promise.resolve(current));
     if (!storage || storage.accounts.length === 0) {
         throw new Error("No accounts to export");
     }