fix(storage): honor reappeared export storage

Author: ndycode

lib/storage.ts

@@ -719,6 +719,7 @@ async function migrateLegacyProjectStorageIfNeeded(options?: {
 	if (!state.currentStoragePath) {
 		return null;
 	}
+	const currentStoragePath = state.currentStoragePath;
 
 	const candidatePaths = [
 		state.currentLegacyWorktreeStoragePath,
@@ -743,10 +744,8 @@ async function migrateLegacyProjectStorageIfNeeded(options?: {
 		return null;
 	}
 
-	let targetStorage = await loadNormalizedStorageFromPath(
-		state.currentStoragePath,
-		"current account storage",
-		{
+	const loadCurrentStorageForMigration = async (): Promise<AccountStorageV3 | null> =>
+		loadNormalizedStorageFromPath(currentStoragePath, "current account storage", {
 			loadAccountsFromPath: (path) =>
 				loadAccountsFromPath(path, {
 					normalizeAccountStorage,
@@ -755,11 +754,29 @@ async function migrateLegacyProjectStorageIfNeeded(options?: {
 			logWarn: (message, details) => {
 				log.warn(message, details);
 			},
-		},
-	);
+		});
+	const readOnlyExportCurrentStorage = async (): Promise<{
+		exists: boolean;
+		storage: AccountStorageV3 | null;
+	}> => {
+		if (commit || !existsSync(currentStoragePath)) {
+			return { exists: false, storage: null };
+		}
+		return {
+			exists: true,
+			storage: await loadCurrentStorageForMigration(),
+		};
+	};
+
+	let targetStorage = await loadCurrentStorageForMigration();
 	let migrated = false;
 
 	for (const legacyPath of existingCandidatePaths) {
+		const liveCurrentStorageBeforeMerge = await readOnlyExportCurrentStorage();
+		if (liveCurrentStorageBeforeMerge.exists) {
+			return liveCurrentStorageBeforeMerge.storage;
+		}
+
 		const legacyStorage = await loadNormalizedStorageFromPath(
 			legacyPath,
 			"legacy account storage",
@@ -778,6 +795,12 @@ async function migrateLegacyProjectStorageIfNeeded(options?: {
 			continue;
 		}
 
+		const liveCurrentStorageAfterLegacyRead =
+			await readOnlyExportCurrentStorage();
+		if (liveCurrentStorageAfterLegacyRead.exists) {
+			return liveCurrentStorageAfterLegacyRead.storage;
+		}
+
 		const mergedStorage = mergeStorageForMigration(
 			targetStorage,
 			legacyStorage,

test/storage.test.ts

@@ -1672,6 +1672,86 @@ describe("storage", () => {
 			}
 		});
 
+		it("does not revive legacy accounts when the current storage reappears before export merges legacy storage", async () => {
+			const currentStoragePath = join(
+				testWorkDir,
+				"accounts-reappeared-current.json",
+			);
+			const legacyStoragePath = join(
+				testWorkDir,
+				"accounts-reappeared-legacy.json",
+			);
+			await fs.writeFile(
+				legacyStoragePath,
+				JSON.stringify({
+					version: 3,
+					activeIndex: 0,
+					activeIndexByFamily: {},
+					accounts: [
+						{
+							accountId: "legacy",
+							refreshToken: "legacy-token",
+							addedAt: 1,
+							lastUsed: 1,
+						},
+					],
+				}),
+			);
+
+			const actualStorageParser = await vi.importActual<
+				typeof import("../lib/storage/storage-parser.js")
+			>("../lib/storage/storage-parser.js");
+			let recreateCurrentStorage = true;
+			vi.resetModules();
+			vi.doMock("../lib/storage/storage-parser.js", () => ({
+				...actualStorageParser,
+				loadAccountsFromPath: vi.fn(async (path, deps) => {
+					if (path === currentStoragePath && recreateCurrentStorage) {
+						recreateCurrentStorage = false;
+						await fs.writeFile(
+							currentStoragePath,
+							JSON.stringify({
+								version: 3,
+								activeIndex: 0,
+								activeIndexByFamily: {},
+								accounts: [],
+							}),
+						);
+						throw Object.assign(new Error("missing current storage"), {
+							code: "ENOENT",
+						});
+					}
+					return actualStorageParser.loadAccountsFromPath(path, deps);
+				}),
+			}));
+
+			try {
+				const isolatedStorageModule = await import("../lib/storage.js");
+				const isolatedPathState = await import("../lib/storage/path-state.js");
+				isolatedPathState.setStoragePathState({
+					currentStoragePath,
+					currentLegacyProjectStoragePath: legacyStoragePath,
+					currentLegacyWorktreeStoragePath: null,
+					currentProjectRoot: null,
+				});
+
+				await expect(
+					isolatedStorageModule.exportAccounts(exportPath),
+				).rejects.toThrow(/No accounts to export/);
+
+				const currentStorage = JSON.parse(
+					await fs.readFile(currentStoragePath, "utf-8"),
+				);
+				expect(currentStorage.accounts).toEqual([]);
+				expect(existsSync(legacyStoragePath)).toBe(true);
+				expect(existsSync(exportPath)).toBe(false);
+			} finally {
+				vi.doUnmock("../lib/storage/storage-parser.js");
+				vi.resetModules();
+				setStoragePathDirect(testStoragePath);
+			}
+		});
+
 		it("does not revive legacy accounts when the current storage has an intentional reset marker", async () => {
 			const currentStoragePath = join(testWorkDir, "accounts-reset-current.json");
 			const legacyStoragePath = join(testWorkDir, "accounts-reset-legacy.json");