fix(storage): defer export legacy migration

Author: ndycode

lib/storage.ts

@@ -1450,11 +1450,9 @@ async function loadAccountsForExport(
 	const persistMigrations = mode === "locked";
 	const path = getStoragePath();
 	const resetMarkerPath = getIntentionalResetMarkerPath(path);
-	const migratedLegacyStorage = await migrateLegacyProjectStorageIfNeeded(
-		persistMigrations
-			? { persist: saveAccountsUnlocked }
-			: { commit: false },
-	);
+	const migrationOptions = persistMigrations
+		? { persist: saveAccountsUnlocked }
+		: { commit: false };
 
 	if (existsSync(resetMarkerPath)) {
 		return createEmptyStorageWithMetadata(false, "intentional-reset");
@@ -1496,6 +1494,11 @@ async function loadAccountsForExport(
 			return createEmptyStorageWithMetadata(false, "intentional-reset");
 		}
 		if (code === "ENOENT") {
+			const migratedLegacyStorage =
+				await migrateLegacyProjectStorageIfNeeded(migrationOptions);
+			if (existsSync(resetMarkerPath)) {
+				return createEmptyStorageWithMetadata(false, "intentional-reset");
+			}
 			return migratedLegacyStorage;
 		}
 		throw error;

test/storage.test.ts

@@ -1234,7 +1234,6 @@ describe("storage", () => {
 		});
 
 		it("should fail export when no accounts exist", async () => {
-			const { exportAccounts } = await import("../lib/storage.js");
 			setStoragePathDirect(testStoragePath);
 			await clearAccounts();
 			await expect(exportAccounts(exportPath)).rejects.toThrow(
@@ -1302,6 +1301,22 @@ describe("storage", () => {
 			const transactionStoragePath = join(testWorkDir, "accounts-transaction.json");
 			const currentStoragePath = join(testWorkDir, "accounts-current.json");
 			const legacyStoragePath = join(testWorkDir, "accounts-legacy.json");
+			await fs.writeFile(
+				transactionStoragePath,
+				JSON.stringify({
+					version: 3,
+					activeIndex: 0,
+					activeIndexByFamily: {},
+					accounts: [
+						{
+							accountId: "transaction",
+							refreshToken: "transaction-token",
+							addedAt: 1,
+							lastUsed: 1,
+						},
+					],
+				}),
+			);
 			await fs.writeFile(
 				legacyStoragePath,
 				JSON.stringify({
@@ -1332,9 +1347,15 @@ describe("storage", () => {
 				});
 
 				const exported = JSON.parse(await fs.readFile(exportPath, "utf-8"));
+				const transactionStorage = JSON.parse(
+					await fs.readFile(transactionStoragePath, "utf-8"),
+				);
 				expect(exported.accounts).toEqual([
 					expect.objectContaining({ refreshToken: "legacy-token" }),
 				]);
+				expect(transactionStorage.accounts).toEqual([
+					expect.objectContaining({ refreshToken: "transaction-token" }),
+				]);
 				expect(existsSync(currentStoragePath)).toBe(false);
 				expect(existsSync(legacyStoragePath)).toBe(true);
 			} finally {
@@ -1435,6 +1456,101 @@ describe("storage", () => {
 			},
 		);
 
+		it("does not revive legacy accounts when the current storage exists but is empty", async () => {
+			const currentStoragePath = join(testWorkDir, "accounts-empty-current.json");
+			const legacyStoragePath = join(testWorkDir, "accounts-empty-legacy.json");
+			await fs.writeFile(
+				currentStoragePath,
+				JSON.stringify({
+					version: 3,
+					activeIndex: 0,
+					activeIndexByFamily: {},
+					accounts: [],
+				}),
+			);
+			await fs.writeFile(
+				legacyStoragePath,
+				JSON.stringify({
+					version: 3,
+					activeIndex: 0,
+					activeIndexByFamily: {},
+					accounts: [
+						{
+							accountId: "legacy",
+							refreshToken: "legacy-token",
+							addedAt: 1,
+							lastUsed: 1,
+						},
+					],
+				}),
+			);
+
+			setStoragePathDirect(currentStoragePath);
+			try {
+				setStoragePathState({
+					currentStoragePath,
+					currentLegacyProjectStoragePath: legacyStoragePath,
+					currentLegacyWorktreeStoragePath: null,
+					currentProjectRoot: null,
+				});
+
+				await expect(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 {
+				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");
+			await fs.writeFile(
+				legacyStoragePath,
+				JSON.stringify({
+					version: 3,
+					activeIndex: 0,
+					activeIndexByFamily: {},
+					accounts: [
+						{
+							accountId: "legacy",
+							refreshToken: "legacy-token",
+							addedAt: 1,
+							lastUsed: 1,
+						},
+					],
+				}),
+			);
+
+			setStoragePathDirect(currentStoragePath);
+			await clearAccounts();
+			try {
+				setStoragePathState({
+					currentStoragePath,
+					currentLegacyProjectStoragePath: legacyStoragePath,
+					currentLegacyWorktreeStoragePath: null,
+					currentProjectRoot: null,
+				});
+
+				await expect(exportAccounts(exportPath)).rejects.toThrow(
+					/No accounts to export/,
+				);
+
+				expect(existsSync(currentStoragePath)).toBe(false);
+				expect(existsSync(legacyStoragePath)).toBe(true);
+				expect(existsSync(exportPath)).toBe(false);
+			} finally {
+				setStoragePathDirect(testStoragePath);
+			}
+		});
+
 		it("should fail import when file does not exist", async () => {
 			const { importAccounts } = await import("../lib/storage.js");
 			const nonexistentPath = join(testWorkDir, "nonexistent-file.json");