fix(storage): share named-backup restore path

Author: ndycode

lib/codex-manager.ts

@@ -57,12 +57,11 @@ import {
 } from "./quota-cache.js";
 import {
 	assessNamedBackupRestore,
-	importAccounts,
 	getNamedBackupsDirectoryPath,
 	isNamedBackupContainmentError,
 	listNamedBackups,
 	NAMED_BACKUP_ASSESS_CONCURRENCY,
-	resolveNamedBackupRestorePath,
+	restoreAssessedNamedBackup,
 	findMatchingAccountIndex,
 	getStoragePath,
 	loadFlaggedAccounts,
@@ -329,6 +328,7 @@ function printUsage(): void {
 			"  codex auth report [--live] [--json] [--model <model>] [--out <path>]",
 			"  codex auth fix [--dry-run] [--json] [--live] [--model <model>]",
 			"  codex auth doctor [--json] [--fix] [--dry-run]",
+			"  codex auth restore-backup",
 			"",
 			"Notes:",
 			"  - Uses ~/.codex/multi-auth/openai-codex-accounts.json",
@@ -4359,10 +4359,7 @@ async function runBackupRestoreManager(
 	if (!confirmed) return;
 
 	try {
-		const validatedBackupPath = await resolveNamedBackupRestorePath(
-			latestAssessment.backup.name,
-		);
-		const result = await importAccounts(validatedBackupPath);
+		const result = await restoreAssessedNamedBackup(latestAssessment);
 		if (!result.changed) {
 			console.log("All accounts in this backup already exist");
 			return;
@@ -4466,6 +4463,18 @@ export async function runCodexMultiAuthCli(rawArgs: string[]): Promise<number> {
 	if (command === "doctor") {
 		return runDoctor(rest);
 	}
+	if (command === "restore-backup") {
+		try {
+			await runBackupRestoreManager(startupDisplaySettings);
+			return 0;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			console.error(
+				`Restore failed: ${collapseWhitespace(message) || "unknown error"}`,
+			);
+			return 1;
+		}
+	}
 
 	console.error(`Unknown command: ${command}`);
 	printUsage();

lib/storage.ts

@@ -1856,16 +1856,21 @@ export async function restoreNamedBackup(
 	name: string,
 ): Promise<ImportAccountsResult> {
 	const assessment = await assessNamedBackupRestore(name);
+	return restoreAssessedNamedBackup(assessment);
+}
+
+export async function restoreAssessedNamedBackup(
+	assessment: Pick<BackupRestoreAssessment, "backup" | "eligibleForRestore" | "error">,
+): Promise<ImportAccountsResult> {
 	if (!assessment.eligibleForRestore) {
 		throw new Error(
 			assessment.error ?? "Backup is not eligible for restore.",
 		);
 	}
-	const validatedPath = assertNamedBackupRestorePath(
-		assessment.backup.path,
-		getNamedBackupRoot(getStoragePath()),
+	const resolvedPath = await resolveNamedBackupRestorePath(
+		assessment.backup.name,
 	);
-	return importAccounts(validatedPath);
+	return importAccounts(resolvedPath);
 }
 
 function parseAndNormalizeStorage(data: unknown): {

test/codex-manager-cli.test.ts

@@ -19,6 +19,7 @@ const assessNamedBackupRestoreMock = vi.fn();
 const getNamedBackupsDirectoryPathMock = vi.fn();
 const resolveNamedBackupRestorePathMock = vi.fn();
 const importAccountsMock = vi.fn();
+const restoreAssessedNamedBackupMock = vi.fn();
 const queuedRefreshMock = vi.fn();
 const setCodexCliActiveSelectionMock = vi.fn();
 const promptAddAnotherAccountMock = vi.fn();
@@ -121,6 +122,7 @@ vi.mock("../lib/storage.js", async () => {
 		getNamedBackupsDirectoryPath: getNamedBackupsDirectoryPathMock,
 		resolveNamedBackupRestorePath: resolveNamedBackupRestorePathMock,
 		importAccounts: importAccountsMock,
+		restoreAssessedNamedBackup: restoreAssessedNamedBackupMock,
 		exportNamedBackup: exportNamedBackupMock,
 		normalizeAccountStorage: normalizeAccountStorageMock,
 	};
@@ -519,6 +521,7 @@ describe("codex manager cli commands", () => {
 		getNamedBackupsDirectoryPathMock.mockReset();
 		resolveNamedBackupRestorePathMock.mockReset();
 		importAccountsMock.mockReset();
+		restoreAssessedNamedBackupMock.mockReset();
 		confirmMock.mockReset();
 		listNamedBackupsMock.mockResolvedValue([]);
 		assessNamedBackupRestoreMock.mockResolvedValue({
@@ -552,6 +555,11 @@ describe("codex manager cli commands", () => {
 			total: 1,
 			changed: true,
 		});
+		restoreAssessedNamedBackupMock.mockImplementation(async (assessment) =>
+			importAccountsMock(
+				await resolveNamedBackupRestorePathMock(assessment.backup.name),
+			),
+		);
 		confirmMock.mockResolvedValue(true);
 		withAccountStorageTransactionMock.mockImplementation(
 			async (handler) => {
@@ -2446,6 +2454,72 @@ describe("codex manager cli commands", () => {
 		expect(setCodexCliActiveSelectionMock).toHaveBeenCalledOnce();
 	});
 
+	it("restores a named backup from the direct restore-backup command", async () => {
+		setInteractiveTTY(true);
+		const now = Date.now();
+		loadAccountsMock.mockResolvedValue({
+			version: 3,
+			activeIndex: 0,
+			activeIndexByFamily: { codex: 0 },
+			accounts: [
+				{
+					email: "settings@example.com",
+					accountId: "acc_settings",
+					refreshToken: "refresh-settings",
+					accessToken: "access-settings",
+					expiresAt: now + 3_600_000,
+					addedAt: now - 1_000,
+					lastUsed: now - 1_000,
+					enabled: true,
+				},
+			],
+		});
+		const assessment = {
+			backup: {
+				name: "named-backup",
+				path: mockBackupPath("named-backup"),
+				createdAt: null,
+				updatedAt: now,
+				sizeBytes: 128,
+				version: 3,
+				accountCount: 1,
+				schemaErrors: [],
+				valid: true,
+				loadError: undefined,
+			},
+			currentAccountCount: 1,
+			mergedAccountCount: 2,
+			imported: 1,
+			skipped: 0,
+			wouldExceedLimit: false,
+			eligibleForRestore: true,
+			error: undefined,
+		};
+		listNamedBackupsMock.mockResolvedValue([assessment.backup]);
+		assessNamedBackupRestoreMock.mockResolvedValue(assessment);
+		selectMock.mockResolvedValueOnce({ type: "restore", assessment });
+
+		const { runCodexMultiAuthCli } = await import("../lib/codex-manager.js");
+		const exitCode = await runCodexMultiAuthCli(["auth", "restore-backup"]);
+
+		expect(exitCode).toBe(0);
+		expect(promptLoginModeMock).not.toHaveBeenCalled();
+		expect(listNamedBackupsMock).toHaveBeenCalledTimes(1);
+		expect(assessNamedBackupRestoreMock).toHaveBeenCalledWith(
+			"named-backup",
+			expect.objectContaining({
+				currentStorage: expect.objectContaining({
+					accounts: expect.any(Array),
+				}),
+			}),
+		);
+		expect(confirmMock).toHaveBeenCalledOnce();
+		expect(importAccountsMock).toHaveBeenCalledWith(
+			mockBackupPath("named-backup"),
+		);
+		expect(setCodexCliActiveSelectionMock).toHaveBeenCalledOnce();
+	});
+
 	it("rejects a restore when the backup root changes before the final import path check", async () => {
 		setInteractiveTTY(true);
 		const now = Date.now();

test/storage.test.ts

@@ -29,6 +29,7 @@ import {
 	loadFlaggedAccounts,
 	normalizeAccountStorage,
 	resolveNamedBackupRestorePath,
+	restoreAssessedNamedBackup,
 	restoreNamedBackup,
 	resolveAccountSelectionIndex,
 	saveFlaggedAccounts,
@@ -2010,6 +2011,36 @@ describe("storage", () => {
 			expect((await loadAccounts())?.accounts ?? []).toHaveLength(0);
 		});
 
+		it("re-resolves an assessed named backup before the final import", async () => {
+			await saveAccounts({
+				version: 3,
+				activeIndex: 0,
+				accounts: [
+					{
+						accountId: "deleted-helper",
+						refreshToken: "ref-deleted-helper",
+						addedAt: 1,
+						lastUsed: 1,
+					},
+				],
+			});
+
+			const backup = await createNamedBackup("deleted-helper-assessment");
+			await clearAccounts();
+
+			const assessment = await assessNamedBackupRestore(
+				"deleted-helper-assessment",
+			);
+			expect(assessment.eligibleForRestore).toBe(true);
+
+			await removeWithRetry(backup.path, { force: true });
+
+			await expect(restoreAssessedNamedBackup(assessment)).rejects.toThrow(
+				/Import file not found/,
+			);
+			expect((await loadAccounts())?.accounts ?? []).toHaveLength(0);
+		});
+
 		it("throws when a named backup becomes invalid JSON after assessment", async () => {
 			await saveAccounts({
 				version: 3,