codex-multi-auth 0.1.5 → 0.1.8

package/dist/lib/storage.js

@@ -1,12 +1,14 @@
-import { promises as fs, existsSync } from "node:fs";
-import { dirname, join } from "node:path";
+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 { ACCOUNT_LIMITS } from "./constants.js";
 import { createLogger } from "./logger.js";
+import { exportNamedBackupFile, resolveNamedBackupPath, } from "./named-backup-export.js";
 import { MODEL_FAMILIES } from "./prompts/codex.js";
 import { AnyAccountStorageSchema, getValidationErrors } from "./schemas.js";
-import { getConfigDir, getProjectConfigDir, getProjectGlobalConfigDir, findProjectRoot, resolvePath, resolveProjectStorageIdentityRoot, } from "./storage/paths.js";
 import { migrateV1ToV3, } from "./storage/migrations.js";
+import { findProjectRoot, getConfigDir, getProjectConfigDir, getProjectGlobalConfigDir, resolvePath, resolveProjectStorageIdentityRoot, } from "./storage/paths.js";
 const log = createLogger("storage");
 const ACCOUNTS_FILE_NAME = "openai-codex-accounts.json";
 const FLAGGED_ACCOUNTS_FILE_NAME = "openai-codex-flagged-accounts.json";
@@ -16,6 +18,7 @@ const ACCOUNTS_WAL_SUFFIX = ".wal";
 const ACCOUNTS_BACKUP_HISTORY_DEPTH = 3;
 const BACKUP_COPY_MAX_ATTEMPTS = 5;
 const BACKUP_COPY_BASE_DELAY_MS = 10;
+const RESET_MARKER_SUFFIX = ".reset-intent";
 let storageBackupEnabled = true;
 let lastAccountsSaveTimestamp = 0;
 /**
@@ -59,6 +62,7 @@ export function formatStorageErrorHint(error, path) {
     }
 }
 let storageMutex = Promise.resolve();
+const transactionSnapshotContext = new AsyncLocalStorage();
 function withStorageLock(fn) {
     const previousMutex = storageMutex;
     let releaseLock;
@@ -67,6 +71,32 @@ function withStorageLock(fn) {
     });
     return previousMutex.then(fn).finally(() => releaseLock());
 }
+function looksLikeSyntheticFixtureAccount(account) {
+    const email = typeof account.email === "string" ? account.email.trim().toLowerCase() : "";
+    const refreshToken = typeof account.refreshToken === "string"
+        ? account.refreshToken.trim().toLowerCase()
+        : "";
+    const accountId = typeof account.accountId === "string"
+        ? account.accountId.trim().toLowerCase()
+        : "";
+    if (!/^account\d+@example\.com$/.test(email)) {
+        return false;
+    }
+    const hasSyntheticRefreshToken = refreshToken.startsWith("fake_refresh") ||
+        /^fake_refresh_token_\d+(_for_testing_only)?$/.test(refreshToken);
+    if (!hasSyntheticRefreshToken) {
+        return false;
+    }
+    if (accountId.length === 0) {
+        return true;
+    }
+    return /^acc(_|-)?\d+$/.test(accountId);
+}
+function looksLikeSyntheticFixtureStorage(storage) {
+    if (!storage || storage.accounts.length === 0)
+        return false;
+    return storage.accounts.every((account) => looksLikeSyntheticFixtureAccount(account));
+}
 async function ensureGitignore(storagePath) {
     if (!currentStoragePath)
         return;
@@ -82,7 +112,10 @@ async function ensureGitignore(storagePath) {
         if (existsSync(gitignorePath)) {
             content = await fs.readFile(gitignorePath, "utf-8");
             const lines = content.split("\n").map((l) => l.trim());
-            if (lines.includes(".codex") || lines.includes(".codex/") || lines.includes("/.codex") || lines.includes("/.codex/")) {
+            if (lines.includes(".codex") ||
+                lines.includes(".codex/") ||
+                lines.includes("/.codex") ||
+                lines.includes("/.codex/")) {
                 return;
             }
         }
@@ -117,6 +150,47 @@ function getAccountsBackupRecoveryCandidates(path) {
     }
     return candidates;
 }
+async function getAccountsBackupRecoveryCandidatesWithDiscovery(path) {
+    const knownCandidates = getAccountsBackupRecoveryCandidates(path);
+    const discoveredCandidates = new Set();
+    const candidatePrefix = `${basename(path)}.`;
+    const knownCandidateSet = new Set(knownCandidates);
+    const directoryPath = dirname(path);
+    try {
+        const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            if (!entry.name.startsWith(candidatePrefix))
+                continue;
+            if (isCacheLikeBackupArtifactName(entry.name))
+                continue;
+            if (entry.name.endsWith(RESET_MARKER_SUFFIX))
+                continue;
+            if (entry.name.endsWith(".tmp"))
+                continue;
+            if (entry.name.includes(".rotate."))
+                continue;
+            if (entry.name.endsWith(ACCOUNTS_WAL_SUFFIX))
+                continue;
+            const candidatePath = join(directoryPath, entry.name);
+            if (knownCandidateSet.has(candidatePath))
+                continue;
+            discoveredCandidates.add(candidatePath);
+        }
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT") {
+            log.warn("Failed to discover account backup candidates", {
+                path,
+                error: String(error),
+            });
+        }
+    }
+    const discoveredOrdered = Array.from(discoveredCandidates).sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
+    return [...knownCandidates, ...discoveredOrdered];
+}
 function getAccountsWalPath(path) {
     return `${path}${ACCOUNTS_WAL_SUFFIX}`;
 }
@@ -173,7 +247,9 @@ async function createRotatingAccountsBackup(path) {
                 continue;
             }
             const stagedPath = buildStagedPath(currentPath, `slot-${i}`);
-            await copyFileWithRetry(previousPath, stagedPath, { allowMissingSource: true });
+            await copyFileWithRetry(previousPath, stagedPath, {
+                allowMissingSource: true,
+            });
             if (existsSync(stagedPath)) {
                 stagedWrites.push({ targetPath: currentPath, stagedPath });
             }
@@ -185,7 +261,10 @@ async function createRotatingAccountsBackup(path) {
         const latestStagedPath = buildStagedPath(latestBackupPath, "latest");
         await copyFileWithRetry(path, latestStagedPath);
         if (existsSync(latestStagedPath)) {
-            stagedWrites.push({ targetPath: latestBackupPath, stagedPath: latestStagedPath });
+            stagedWrites.push({
+                targetPath: latestBackupPath,
+                stagedPath: latestStagedPath,
+            });
         }
         for (const stagedWrite of stagedWrites) {
             await renameFileWithRetry(stagedWrite.stagedPath, stagedWrite.targetPath);
@@ -207,7 +286,8 @@ async function createRotatingAccountsBackup(path) {
 }
 function isRotatingBackupTempArtifact(storagePath, candidatePath) {
     const backupPrefix = `${storagePath}${ACCOUNTS_BACKUP_SUFFIX}`;
-    if (!candidatePath.startsWith(backupPrefix) || !candidatePath.endsWith(".tmp")) {
+    if (!candidatePath.startsWith(backupPrefix) ||
+        !candidatePath.endsWith(".tmp")) {
         return false;
     }
     const suffix = candidatePath.slice(backupPrefix.length);
@@ -224,7 +304,9 @@ function isRotatingBackupTempArtifact(storagePath, candidatePath) {
 async function cleanupStaleRotatingBackupArtifacts(path) {
     const directoryPath = dirname(path);
     try {
-        const directoryEntries = await fs.readdir(directoryPath, { withFileTypes: true });
+        const directoryEntries = await fs.readdir(directoryPath, {
+            withFileTypes: true,
+        });
         const staleArtifacts = directoryEntries
             .filter((entry) => entry.isFile())
             .map((entry) => join(directoryPath, entry.name))
@@ -257,6 +339,198 @@ async function cleanupStaleRotatingBackupArtifacts(path) {
 function computeSha256(value) {
     return createHash("sha256").update(value).digest("hex");
 }
+function getIntentionalResetMarkerPath(path) {
+    return `${path}${RESET_MARKER_SUFFIX}`;
+}
+function createEmptyStorageWithMetadata(restoreEligible, restoreReason) {
+    return {
+        version: 3,
+        accounts: [],
+        activeIndex: 0,
+        activeIndexByFamily: {},
+        restoreEligible,
+        restoreReason,
+    };
+}
+function withRestoreMetadata(storage, restoreEligible, restoreReason) {
+    return {
+        ...storage,
+        restoreEligible,
+        restoreReason,
+    };
+}
+function isCacheLikeBackupArtifactName(entryName) {
+    return entryName.toLowerCase().includes(".cache");
+}
+async function statSnapshot(path) {
+    try {
+        const stats = await fs.stat(path);
+        return { exists: true, bytes: stats.size, mtimeMs: stats.mtimeMs };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT") {
+            log.warn("Failed to stat backup candidate", {
+                path,
+                error: String(error),
+            });
+        }
+        return { exists: false };
+    }
+}
+async function describeAccountSnapshot(path, kind, index) {
+    const stats = await statSnapshot(path);
+    if (!stats.exists) {
+        return { kind, path, index, exists: false, valid: false };
+    }
+    try {
+        const { normalized, schemaErrors, storedVersion } = await loadAccountsFromPath(path);
+        return {
+            kind,
+            path,
+            index,
+            exists: true,
+            valid: !!normalized,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+            version: typeof storedVersion === "number" ? storedVersion : undefined,
+            accountCount: normalized?.accounts.length,
+            schemaErrors: schemaErrors.length > 0 ? schemaErrors : undefined,
+        };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT") {
+            log.warn("Failed to inspect account snapshot", {
+                path,
+                error: String(error),
+            });
+        }
+        return {
+            kind,
+            path,
+            index,
+            exists: true,
+            valid: false,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+        };
+    }
+}
+async function describeAccountsWalSnapshot(path) {
+    const stats = await statSnapshot(path);
+    if (!stats.exists) {
+        return { kind: "accounts-wal", path, exists: false, valid: false };
+    }
+    try {
+        const raw = await fs.readFile(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed)) {
+            return {
+                kind: "accounts-wal",
+                path,
+                exists: true,
+                valid: false,
+                bytes: stats.bytes,
+                mtimeMs: stats.mtimeMs,
+            };
+        }
+        const entry = parsed;
+        if (entry.version !== 1 ||
+            typeof entry.content !== "string" ||
+            typeof entry.checksum !== "string" ||
+            computeSha256(entry.content) !== entry.checksum) {
+            return {
+                kind: "accounts-wal",
+                path,
+                exists: true,
+                valid: false,
+                bytes: stats.bytes,
+                mtimeMs: stats.mtimeMs,
+            };
+        }
+        const { normalized, storedVersion, schemaErrors } = parseAndNormalizeStorage(JSON.parse(entry.content));
+        return {
+            kind: "accounts-wal",
+            path,
+            exists: true,
+            valid: !!normalized,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+            version: typeof storedVersion === "number" ? storedVersion : undefined,
+            accountCount: normalized?.accounts.length,
+            schemaErrors: schemaErrors.length > 0 ? schemaErrors : undefined,
+        };
+    }
+    catch {
+        return {
+            kind: "accounts-wal",
+            path,
+            exists: true,
+            valid: false,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+        };
+    }
+}
+async function loadFlaggedAccountsFromPath(path) {
+    const content = await fs.readFile(path, "utf-8");
+    const data = JSON.parse(content);
+    return normalizeFlaggedStorage(data);
+}
+async function describeFlaggedSnapshot(path, kind, index) {
+    const stats = await statSnapshot(path);
+    if (!stats.exists) {
+        return { kind, path, index, exists: false, valid: false };
+    }
+    try {
+        const storage = await loadFlaggedAccountsFromPath(path);
+        return {
+            kind,
+            path,
+            index,
+            exists: true,
+            valid: true,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+            version: storage.version,
+            flaggedCount: storage.accounts.length,
+        };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT") {
+            log.warn("Failed to inspect flagged snapshot", {
+                path,
+                error: String(error),
+            });
+        }
+        return {
+            kind,
+            path,
+            index,
+            exists: true,
+            valid: false,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+        };
+    }
+}
+function latestValidSnapshot(snapshots) {
+    return snapshots
+        .filter((snapshot) => snapshot.valid)
+        .sort((left, right) => (right.mtimeMs ?? 0) - (left.mtimeMs ?? 0))[0];
+}
+function buildMetadataSection(storagePath, snapshots) {
+    const latestValid = latestValidSnapshot(snapshots);
+    return {
+        storagePath,
+        latestValidPath: latestValid?.path,
+        snapshotCount: snapshots.length,
+        validSnapshotCount: snapshots.filter((snapshot) => snapshot.valid).length,
+        snapshots,
+    };
+}
 export function getLastAccountsSaveTimestamp() {
     return lastAccountsSaveTimestamp;
 }
@@ -276,7 +550,9 @@ export function setStoragePath(projectPath) {
         currentLegacyProjectStoragePath = join(getProjectConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
         const previousWorktreeScopedPath = join(getProjectGlobalConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
         currentLegacyWorktreeStoragePath =
-            previousWorktreeScopedPath !== currentStoragePath ? previousWorktreeScopedPath : null;
+            previousWorktreeScopedPath !== currentStoragePath
+                ? previousWorktreeScopedPath
+                : null;
     }
     else {
         currentStoragePath = null;
@@ -301,6 +577,15 @@ export function getStoragePath() {
     }
     return join(getConfigDir(), ACCOUNTS_FILE_NAME);
 }
+export function buildNamedBackupPath(name) {
+    return resolveNamedBackupPath(name, getStoragePath());
+}
+export async function exportNamedBackup(name, options) {
+    return exportNamedBackupFile(name, {
+        getStoragePath,
+        exportAccounts,
+    }, options);
+}
 export function getFlaggedAccountsPath() {
     return join(dirname(getStoragePath()), FLAGGED_ACCOUNTS_FILE_NAME);
 }
@@ -311,8 +596,13 @@ async function migrateLegacyProjectStorageIfNeeded(persist = saveAccounts) {
     if (!currentStoragePath) {
         return null;
     }
-    const candidatePaths = [currentLegacyWorktreeStoragePath, currentLegacyProjectStoragePath]
-        .filter((path) => typeof path === "string" && path.length > 0 && path !== currentStoragePath)
+    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;
@@ -506,7 +796,8 @@ export function deduplicateAccountsByEmail(accounts) {
         const existingAddedAt = existing.addedAt || 0;
         const candidateAddedAt = account.addedAt || 0;
         const isNewer = candidateLastUsed > existingLastUsed ||
-            (candidateLastUsed === existingLastUsed && candidateAddedAt > existingAddedAt);
+            (candidateLastUsed === existingLastUsed &&
+                candidateAddedAt > existingAddedAt);
         if (isNewer) {
             emailToNewestIndex.set(email, i);
         }
@@ -578,7 +869,9 @@ export function normalizeAccountStorage(data) {
     const baseStorage = fromVersion === 1
         ? migrateV1ToV3(data)
         : data;
-    const validAccounts = rawAccounts.filter((account) => isRecord(account) && typeof account.refreshToken === "string" && !!account.refreshToken.trim());
+    const validAccounts = rawAccounts.filter((account) => isRecord(account) &&
+        typeof account.refreshToken === "string" &&
+        !!account.refreshToken.trim());
     const deduplicatedAccounts = deduplicateAccountsByEmail(deduplicateAccountsByKey(validAccounts));
     const activeIndex = (() => {
         if (deduplicatedAccounts.length === 0)
@@ -625,10 +918,88 @@ export function normalizeAccountStorage(data) {
 export async function loadAccounts() {
     return loadAccountsInternal(saveAccounts);
 }
+export async function getBackupMetadata() {
+    const storagePath = getStoragePath();
+    const walPath = getAccountsWalPath(storagePath);
+    const accountCandidates = await getAccountsBackupRecoveryCandidatesWithDiscovery(storagePath);
+    const accountSnapshots = [
+        await describeAccountSnapshot(storagePath, "accounts-primary"),
+        await describeAccountsWalSnapshot(walPath),
+    ];
+    for (const [index, candidate] of accountCandidates.entries()) {
+        const kind = candidate === `${storagePath}.bak`
+            ? "accounts-backup"
+            : candidate.startsWith(`${storagePath}.bak.`)
+                ? "accounts-backup-history"
+                : "accounts-discovered-backup";
+        accountSnapshots.push(await describeAccountSnapshot(candidate, kind, index));
+    }
+    const flaggedPath = getFlaggedAccountsPath();
+    const flaggedCandidates = await getAccountsBackupRecoveryCandidatesWithDiscovery(flaggedPath);
+    const flaggedSnapshots = [
+        await describeFlaggedSnapshot(flaggedPath, "flagged-primary"),
+    ];
+    for (const [index, candidate] of flaggedCandidates.entries()) {
+        const kind = candidate === `${flaggedPath}.bak`
+            ? "flagged-backup"
+            : candidate.startsWith(`${flaggedPath}.bak.`)
+                ? "flagged-backup-history"
+                : "flagged-discovered-backup";
+        flaggedSnapshots.push(await describeFlaggedSnapshot(candidate, kind, index));
+    }
+    return {
+        accounts: buildMetadataSection(storagePath, accountSnapshots),
+        flaggedAccounts: buildMetadataSection(flaggedPath, flaggedSnapshots),
+    };
+}
+export async function getRestoreAssessment() {
+    const storagePath = getStoragePath();
+    const resetMarkerPath = getIntentionalResetMarkerPath(storagePath);
+    const backupMetadata = await getBackupMetadata();
+    if (existsSync(resetMarkerPath)) {
+        return {
+            storagePath,
+            restoreEligible: false,
+            restoreReason: "intentional-reset",
+            backupMetadata,
+        };
+    }
+    const primarySnapshot = backupMetadata.accounts.snapshots.find((snapshot) => snapshot.kind === "accounts-primary");
+    if (!primarySnapshot?.exists) {
+        return {
+            storagePath,
+            restoreEligible: true,
+            restoreReason: "missing-storage",
+            latestSnapshot: backupMetadata.accounts.latestValidPath
+                ? backupMetadata.accounts.snapshots.find((snapshot) => snapshot.path === backupMetadata.accounts.latestValidPath)
+                : undefined,
+            backupMetadata,
+        };
+    }
+    if (primarySnapshot.valid && primarySnapshot.accountCount === 0) {
+        return {
+            storagePath,
+            restoreEligible: true,
+            restoreReason: "empty-storage",
+            latestSnapshot: primarySnapshot,
+            backupMetadata,
+        };
+    }
+    return {
+        storagePath,
+        restoreEligible: false,
+        latestSnapshot: backupMetadata.accounts.latestValidPath
+            ? backupMetadata.accounts.snapshots.find((snapshot) => snapshot.path === backupMetadata.accounts.latestValidPath)
+            : undefined,
+        backupMetadata,
+    };
+}
 function parseAndNormalizeStorage(data) {
     const schemaErrors = getValidationErrors(AnyAccountStorageSchema, data);
     const normalized = normalizeAccountStorage(data);
-    const storedVersion = isRecord(data) ? data.version : undefined;
+    const storedVersion = isRecord(data)
+        ? data.version
+        : undefined;
     return { normalized, storedVersion, schemaErrors };
 }
 async function loadAccountsFromPath(path) {
@@ -638,8 +1009,15 @@ async function loadAccountsFromPath(path) {
 }
 async function loadAccountsFromJournal(path) {
     const walPath = getAccountsWalPath(path);
+    const resetMarkerPath = getIntentionalResetMarkerPath(path);
+    if (existsSync(resetMarkerPath)) {
+        return null;
+    }
     try {
         const raw = await fs.readFile(walPath, "utf-8");
+        if (existsSync(resetMarkerPath)) {
+            return null;
+        }
         const parsed = JSON.parse(raw);
         if (!isRecord(parsed))
             return null;
@@ -663,13 +1041,17 @@ async function loadAccountsFromJournal(path) {
     catch (error) {
         const code = error.code;
         if (code !== "ENOENT") {
-            log.warn("Failed to load account WAL journal", { path: walPath, error: String(error) });
+            log.warn("Failed to load account WAL journal", {
+                path: walPath,
+                error: String(error),
+            });
         }
         return null;
     }
 }
 async function loadAccountsInternal(persistMigration) {
     const path = getStoragePath();
+    const resetMarkerPath = getIntentionalResetMarkerPath(path);
     await cleanupStaleRotatingBackupArtifacts(path);
     const migratedLegacyStorage = persistMigration
         ? await migrateLegacyProjectStorageIfNeeded(persistMigration)
@@ -677,16 +1059,73 @@ async function loadAccountsInternal(persistMigration) {
     try {
         const { normalized, storedVersion, schemaErrors } = await loadAccountsFromPath(path);
         if (schemaErrors.length > 0) {
-            log.warn("Account storage schema validation warnings", { errors: schemaErrors.slice(0, 5) });
+            log.warn("Account storage schema validation warnings", {
+                errors: schemaErrors.slice(0, 5),
+            });
         }
         if (normalized && storedVersion !== normalized.version) {
-            log.info("Migrating account storage to v3", { from: storedVersion, to: normalized.version });
+            log.info("Migrating account storage to v3", {
+                from: storedVersion,
+                to: normalized.version,
+            });
             if (persistMigration) {
                 try {
                     await persistMigration(normalized);
                 }
                 catch (saveError) {
-                    log.warn("Failed to persist migrated storage", { error: String(saveError) });
+                    log.warn("Failed to persist migrated storage", {
+                        error: String(saveError),
+                    });
+                }
+            }
+        }
+        if (existsSync(resetMarkerPath)) {
+            return createEmptyStorageWithMetadata(false, "intentional-reset");
+        }
+        if (normalized && normalized.accounts.length === 0) {
+            return withRestoreMetadata(normalized, true, "empty-storage");
+        }
+        const primaryLooksSynthetic = looksLikeSyntheticFixtureStorage(normalized);
+        if (storageBackupEnabled && normalized && primaryLooksSynthetic) {
+            const backupCandidates = await getAccountsBackupRecoveryCandidatesWithDiscovery(path);
+            for (const backupPath of backupCandidates) {
+                if (backupPath === path)
+                    continue;
+                try {
+                    const backup = await loadAccountsFromPath(backupPath);
+                    if (!backup.normalized)
+                        continue;
+                    if (looksLikeSyntheticFixtureStorage(backup.normalized))
+                        continue;
+                    if (backup.normalized.accounts.length <= 0)
+                        continue;
+                    log.warn("Detected synthetic primary account storage; promoting backup", {
+                        path,
+                        backupPath,
+                        primaryAccounts: normalized.accounts.length,
+                        backupAccounts: backup.normalized.accounts.length,
+                    });
+                    if (persistMigration) {
+                        try {
+                            await persistMigration(backup.normalized);
+                        }
+                        catch (persistError) {
+                            log.warn("Failed to persist promoted backup storage", {
+                                path,
+                                error: String(persistError),
+                            });
+                        }
+                    }
+                    return backup.normalized;
+                }
+                catch (backupError) {
+                    const backupCode = backupError.code;
+                    if (backupCode !== "ENOENT") {
+                        log.warn("Failed to load candidate backup for synthetic-primary promotion", {
+                            path: backupPath,
+                            error: String(backupError),
+                        });
+                    }
                 }
             }
         }
@@ -694,6 +1133,9 @@ async function loadAccountsInternal(persistMigration) {
     }
     catch (error) {
         const code = error.code;
+        if (existsSync(resetMarkerPath)) {
+            return createEmptyStorageWithMetadata(false, "intentional-reset");
+        }
         if (code === "ENOENT" && migratedLegacyStorage) {
             return migratedLegacyStorage;
         }
@@ -712,8 +1154,11 @@ async function loadAccountsInternal(persistMigration) {
             }
             return recoveredFromWal;
         }
+        if (existsSync(resetMarkerPath)) {
+            return createEmptyStorageWithMetadata(false, "intentional-reset");
+        }
         if (storageBackupEnabled) {
-            const backupCandidates = getAccountsBackupRecoveryCandidates(path);
+            const backupCandidates = await getAccountsBackupRecoveryCandidatesWithDiscovery(path);
             for (const backupPath of backupCandidates) {
                 try {
                     const backup = await loadAccountsFromPath(backupPath);
@@ -724,7 +1169,10 @@ async function loadAccountsInternal(persistMigration) {
                         });
                     }
                     if (backup.normalized) {
-                        log.warn("Recovered account storage from backup file", { path, backupPath });
+                        log.warn("Recovered account storage from backup file", {
+                            path,
+                            backupPath,
+                        });
                         if (persistMigration) {
                             try {
                                 await persistMigration(backup.normalized);
@@ -753,17 +1201,37 @@ async function loadAccountsInternal(persistMigration) {
         if (code !== "ENOENT") {
             log.error("Failed to load account storage", { error: String(error) });
         }
+        if (code === "ENOENT") {
+            return createEmptyStorageWithMetadata(true, "missing-storage");
+        }
         return null;
     }
 }
 async function saveAccountsUnlocked(storage) {
     const path = getStoragePath();
+    const resetMarkerPath = getIntentionalResetMarkerPath(path);
     const uniqueSuffix = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
     const tempPath = `${path}.${uniqueSuffix}.tmp`;
     const walPath = getAccountsWalPath(path);
     try {
         await fs.mkdir(dirname(path), { recursive: true });
         await ensureGitignore(path);
+        if (looksLikeSyntheticFixtureStorage(storage)) {
+            try {
+                const existing = await loadNormalizedStorageFromPath(path, "existing account storage");
+                if (existing &&
+                    existing.accounts.length > 0 &&
+                    !looksLikeSyntheticFixtureStorage(existing)) {
+                    throw new StorageError("Refusing to overwrite non-synthetic account storage with synthetic fixture payload", "EINVALID", path, "Detected synthetic fixture-like account payload. Use explicit account import/login commands instead.");
+                }
+            }
+            catch (error) {
+                if (error instanceof StorageError) {
+                    throw error;
+                }
+                // Ignore existing-file probe failures and continue with normal save flow.
+            }
+        }
         if (storageBackupEnabled && existsSync(path)) {
             try {
                 await createRotatingAccountsBackup(path);
@@ -799,6 +1267,12 @@ async function saveAccountsUnlocked(storage) {
         for (let attempt = 0; attempt < 5; attempt++) {
             try {
                 await fs.rename(tempPath, path);
+                try {
+                    await fs.unlink(resetMarkerPath);
+                }
+                catch {
+                    // Best effort cleanup.
+                }
                 lastAccountsSaveTimestamp = Date.now();
                 try {
                     await fs.unlink(walPath);
@@ -812,7 +1286,7 @@ async function saveAccountsUnlocked(storage) {
                 const code = renameError.code;
                 if (code === "EPERM" || code === "EBUSY") {
                     lastError = renameError;
-                    await new Promise(r => setTimeout(r, 10 * Math.pow(2, attempt)));
+                    await new Promise((r) => setTimeout(r, 10 * 2 ** attempt));
                     continue;
                 }
                 throw renameError;
@@ -842,8 +1316,16 @@ async function saveAccountsUnlocked(storage) {
 }
 export async function withAccountStorageTransaction(handler) {
     return withStorageLock(async () => {
-        const current = await loadAccountsInternal(saveAccountsUnlocked);
-        return handler(current, saveAccountsUnlocked);
+        const state = {
+            snapshot: await loadAccountsInternal(saveAccountsUnlocked),
+            active: true,
+        };
+        const current = state.snapshot;
+        const persist = async (storage) => {
+            await saveAccountsUnlocked(storage);
+            state.snapshot = storage;
+        };
+        return transactionSnapshotContext.run(state, () => handler(current, persist));
     });
 }
 /**
@@ -865,8 +1347,10 @@ export async function saveAccounts(storage) {
 export async function clearAccounts() {
     return withStorageLock(async () => {
         const path = getStoragePath();
+        const resetMarkerPath = getIntentionalResetMarkerPath(path);
         const walPath = getAccountsWalPath(path);
-        const backupPaths = getAccountsBackupRecoveryCandidates(path);
+        const backupPaths = await getAccountsBackupRecoveryCandidatesWithDiscovery(path);
+        await fs.writeFile(resetMarkerPath, JSON.stringify({ version: 1, createdAt: Date.now() }), { encoding: "utf-8", mode: 0o600 });
         const clearPath = async (targetPath) => {
             try {
                 await fs.unlink(targetPath);
@@ -882,7 +1366,11 @@ export async function clearAccounts() {
             }
         };
         try {
-            await Promise.all([clearPath(path), clearPath(walPath), ...backupPaths.map(clearPath)]);
+            await Promise.all([
+                clearPath(path),
+                clearPath(walPath),
+                ...backupPaths.map(clearPath),
+            ]);
         }
         catch {
             // Individual path cleanup is already best-effort with per-artifact logging.
@@ -897,13 +1385,22 @@ function normalizeFlaggedStorage(data) {
     for (const rawAccount of data.accounts) {
         if (!isRecord(rawAccount))
             continue;
-        const refreshToken = typeof rawAccount.refreshToken === "string" ? rawAccount.refreshToken.trim() : "";
+        const refreshToken = typeof rawAccount.refreshToken === "string"
+            ? rawAccount.refreshToken.trim()
+            : "";
         if (!refreshToken)
             continue;
-        const flaggedAt = typeof rawAccount.flaggedAt === "number" ? rawAccount.flaggedAt : Date.now();
-        const isAccountIdSource = (value) => value === "token" || value === "id_token" || value === "org" || value === "manual";
+        const flaggedAt = typeof rawAccount.flaggedAt === "number"
+            ? rawAccount.flaggedAt
+            : Date.now();
+        const isAccountIdSource = (value) => value === "token" ||
+            value === "id_token" ||
+            value === "org" ||
+            value === "manual";
         const isSwitchReason = (value) => value === "rate-limit" || value === "initial" || value === "rotation";
-        const isCooldownReason = (value) => value === "auth-failure" || value === "network-error" || value === "rate-limit";
+        const isCooldownReason = (value) => value === "auth-failure" ||
+            value === "network-error" ||
+            value === "rate-limit";
         let rateLimitResetTimes;
         if (isRecord(rawAccount.rateLimitResetTimes)) {
             const normalizedRateLimits = {};
@@ -928,19 +1425,33 @@ function normalizeFlaggedStorage(data) {
         const normalized = {
             refreshToken,
             addedAt: typeof rawAccount.addedAt === "number" ? rawAccount.addedAt : flaggedAt,
-            lastUsed: typeof rawAccount.lastUsed === "number" ? rawAccount.lastUsed : flaggedAt,
-            accountId: typeof rawAccount.accountId === "string" ? rawAccount.accountId : undefined,
+            lastUsed: typeof rawAccount.lastUsed === "number"
+                ? rawAccount.lastUsed
+                : flaggedAt,
+            accountId: typeof rawAccount.accountId === "string"
+                ? rawAccount.accountId
+                : undefined,
             accountIdSource,
-            accountLabel: typeof rawAccount.accountLabel === "string" ? rawAccount.accountLabel : undefined,
+            accountLabel: typeof rawAccount.accountLabel === "string"
+                ? rawAccount.accountLabel
+                : undefined,
             email: typeof rawAccount.email === "string" ? rawAccount.email : undefined,
-            enabled: typeof rawAccount.enabled === "boolean" ? rawAccount.enabled : undefined,
+            enabled: typeof rawAccount.enabled === "boolean"
+                ? rawAccount.enabled
+                : undefined,
             lastSwitchReason,
             rateLimitResetTimes,
-            coolingDownUntil: typeof rawAccount.coolingDownUntil === "number" ? rawAccount.coolingDownUntil : undefined,
+            coolingDownUntil: typeof rawAccount.coolingDownUntil === "number"
+                ? rawAccount.coolingDownUntil
+                : undefined,
             cooldownReason,
             flaggedAt,
-            flaggedReason: typeof rawAccount.flaggedReason === "string" ? rawAccount.flaggedReason : undefined,
-            lastError: typeof rawAccount.lastError === "string" ? rawAccount.lastError : undefined,
+            flaggedReason: typeof rawAccount.flaggedReason === "string"
+                ? rawAccount.flaggedReason
+                : undefined,
+            lastError: typeof rawAccount.lastError === "string"
+                ? rawAccount.lastError
+                : undefined,
         };
         byRefreshToken.set(refreshToken, normalized);
     }
@@ -951,16 +1462,24 @@ function normalizeFlaggedStorage(data) {
 }
 export async function loadFlaggedAccounts() {
     const path = getFlaggedAccountsPath();
+    const resetMarkerPath = getIntentionalResetMarkerPath(path);
     const empty = { version: 1, accounts: [] };
     try {
         const content = await fs.readFile(path, "utf-8");
         const data = JSON.parse(content);
-        return normalizeFlaggedStorage(data);
+        const loaded = normalizeFlaggedStorage(data);
+        if (existsSync(resetMarkerPath)) {
+            return empty;
+        }
+        return loaded;
     }
     catch (error) {
         const code = error.code;
         if (code !== "ENOENT") {
-            log.error("Failed to load flagged account storage", { path, error: String(error) });
+            log.error("Failed to load flagged account storage", {
+                path,
+                error: String(error),
+            });
             return empty;
         }
     }
@@ -1000,13 +1519,31 @@ export async function loadFlaggedAccounts() {
 export async function saveFlaggedAccounts(storage) {
     return withStorageLock(async () => {
         const path = getFlaggedAccountsPath();
+        const markerPath = getIntentionalResetMarkerPath(path);
         const uniqueSuffix = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
         const tempPath = `${path}.${uniqueSuffix}.tmp`;
         try {
             await fs.mkdir(dirname(path), { recursive: true });
+            if (existsSync(path)) {
+                try {
+                    await fs.copyFile(path, `${path}.bak`);
+                }
+                catch (backupError) {
+                    log.warn("Failed to create flagged backup snapshot", {
+                        path,
+                        error: String(backupError),
+                    });
+                }
+            }
             const content = JSON.stringify(normalizeFlaggedStorage(storage), null, 2);
             await fs.writeFile(tempPath, content, { encoding: "utf-8", mode: 0o600 });
             await fs.rename(tempPath, path);
+            try {
+                await fs.unlink(markerPath);
+            }
+            catch {
+                // Best effort cleanup.
+            }
         }
         catch (error) {
             try {
@@ -1015,20 +1552,48 @@ export async function saveFlaggedAccounts(storage) {
             catch {
                 // Ignore cleanup failures.
             }
-            log.error("Failed to save flagged account storage", { path, error: String(error) });
+            log.error("Failed to save flagged account storage", {
+                path,
+                error: String(error),
+            });
             throw error;
         }
     });
 }
 export async function clearFlaggedAccounts() {
     return withStorageLock(async () => {
+        const path = getFlaggedAccountsPath();
+        const markerPath = getIntentionalResetMarkerPath(path);
         try {
-            await fs.unlink(getFlaggedAccountsPath());
+            await fs.writeFile(markerPath, "reset", {
+                encoding: "utf-8",
+                mode: 0o600,
+            });
         }
         catch (error) {
-            const code = error.code;
-            if (code !== "ENOENT") {
-                log.error("Failed to clear flagged account storage", { error: String(error) });
+            log.error("Failed to write flagged reset marker", {
+                path,
+                markerPath,
+                error: String(error),
+            });
+            throw error;
+        }
+        const backupPaths = await getAccountsBackupRecoveryCandidatesWithDiscovery(path);
+        for (const candidate of [path, ...backupPaths, markerPath]) {
+            try {
+                await fs.unlink(candidate);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== "ENOENT") {
+                    log.error("Failed to clear flagged account storage", {
+                        path: candidate,
+                        error: String(error),
+                    });
+                    if (candidate === path) {
+                        throw error;
+                    }
+                }
             }
         }
     });
@@ -1039,19 +1604,34 @@ export async function clearFlaggedAccounts() {
  * @param force - If true, overwrite existing file (default: true)
  * @throws Error if file exists and force is false, or if no accounts to export
  */
-export async function exportAccounts(filePath, force = true) {
+export async function exportAccounts(filePath, force = true, beforeCommit) {
     const resolvedPath = resolvePath(filePath);
     if (!force && existsSync(resolvedPath)) {
         throw new Error(`File already exists: ${resolvedPath}`);
     }
-    const storage = await withAccountStorageTransaction((current) => Promise.resolve(current));
+    const transactionState = transactionSnapshotContext.getStore();
+    const storage = transactionState?.active
+        ? transactionState.snapshot
+        : await withAccountStorageTransaction((current) => Promise.resolve(current));
     if (!storage || storage.accounts.length === 0) {
         throw new Error("No accounts to export");
     }
     await fs.mkdir(dirname(resolvedPath), { recursive: true });
-    const content = JSON.stringify(storage, null, 2);
+    await beforeCommit?.(resolvedPath);
+    if (!force && existsSync(resolvedPath)) {
+        throw new Error(`File already exists: ${resolvedPath}`);
+    }
+    const content = JSON.stringify({
+        version: storage.version,
+        accounts: storage.accounts,
+        activeIndex: storage.activeIndex,
+        activeIndexByFamily: storage.activeIndexByFamily,
+    }, null, 2);
     await fs.writeFile(resolvedPath, content, { encoding: "utf-8", mode: 0o600 });
-    log.info("Exported accounts", { path: resolvedPath, count: storage.accounts.length });
+    log.info("Exported accounts", {
+        path: resolvedPath,
+        count: storage.accounts.length,
+    });
 }
 /**
  * Imports accounts from a JSON file, merging with existing accounts.
@@ -1077,7 +1657,7 @@ export async function importAccounts(filePath) {
     if (!normalized) {
         throw new Error("Invalid account storage format");
     }
-    const { imported: importedCount, total, skipped: skippedCount } = await withAccountStorageTransaction(async (existing, persist) => {
+    const { imported: importedCount, total, skipped: skippedCount, } = await withAccountStorageTransaction(async (existing, persist) => {
         const existingAccounts = existing?.accounts ?? [];
         const existingActiveIndex = existing?.activeIndex ?? 0;
         const merged = [...existingAccounts, ...normalized.accounts];
@@ -1099,7 +1679,12 @@ export async function importAccounts(filePath) {
         const skipped = normalized.accounts.length - imported;
         return { imported, total: deduplicatedAccounts.length, skipped };
     });
-    log.info("Imported accounts", { path: resolvedPath, imported: importedCount, skipped: skippedCount, total });
+    log.info("Imported accounts", {
+        path: resolvedPath,
+        imported: importedCount,
+        skipped: skippedCount,
+        total,
+    });
     return { imported: importedCount, total, skipped: skippedCount };
 }
 //# sourceMappingURL=storage.js.map