@minniexcode/codex-switch 0.0.2 → 0.0.4

package/dist/cli.js

@@ -1,51 +1,73 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printHelp = printHelp;
 exports.printVersion = printVersion;
 exports.executeCommand = executeCommand;
+const fs = __importStar(require("node:fs"));
 const add_provider_1 = require("./app/add-provider");
+const edit_provider_1 = require("./app/edit-provider");
 const export_providers_1 = require("./app/export-providers");
 const get_current_profile_1 = require("./app/get-current-profile");
 const get_status_1 = require("./app/get-status");
 const import_providers_1 = require("./app/import-providers");
+const list_backups_1 = require("./app/list-backups");
 const list_providers_1 = require("./app/list-providers");
 const remove_provider_1 = require("./app/remove-provider");
-const rollback_latest_1 = require("./app/rollback-latest");
+const rollback_backup_1 = require("./app/rollback-backup");
 const run_doctor_1 = require("./app/run-doctor");
+const setup_codex_1 = require("./app/setup-codex");
+const show_provider_1 = require("./app/show-provider");
 const switch_provider_1 = require("./app/switch-provider");
 const errors_1 = require("./domain/errors");
+const config_repo_1 = require("./infra/config-repo");
+const providers_repo_1 = require("./infra/providers-repo");
 const codex_paths_1 = require("./infra/codex-paths");
 const args_1 = require("./cli/args");
+const add_interactive_1 = require("./cli/add-interactive");
+const help_1 = require("./cli/help");
+const interactive_1 = require("./cli/interactive");
 const output_1 = require("./cli/output");
-const VERSION = "0.0.2";
-const HELP_TEXT = `codex-switch
-
-Usage:
-  codexs <command> [options]
-
-Commands:
-  codexs list
-  codexs current
-  codexs switch <provider> [--no-login]
-  codexs status
-  codexs import <file>
-  codexs export <file> [--force]
-  codexs add <provider> --profile <name> --api-key <key> [--base-url <url>] [--note <text>] [--tag <tag> ...]
-  codexs remove <provider> --force
-  codexs doctor
-  codexs rollback
-
-Global options:
-  --json
-  --codex-dir <path>
-  --help
-  --version`;
+const prompt_1 = require("./cli/prompt");
+const VERSION = "0.0.4";
 /**
  * Prints the command help text to stdout.
  */
-function printHelp() {
-    process.stdout.write(`${HELP_TEXT}\n`);
+function printHelp(commandName) {
+    process.stdout.write(`${(0, help_1.buildHelpText)(commandName)}\n`);
 }
 /**
  * Prints the current CLI version to stdout.
@@ -58,16 +80,22 @@ function printVersion() {
  */
 function main() {
     const parsed = (0, args_1.parseArgs)(process.argv.slice(2));
-    if (!parsed.command) {
-        printHelp();
+    if (parsed.versionRequested) {
+        printVersion();
         process.exit(0);
     }
-    if (parsed.command === "help") {
-        printHelp();
+    if (parsed.helpRequested) {
+        if (parsed.helpTarget && !(0, help_1.isKnownCommandName)(parsed.helpTarget)) {
+            (0, output_1.outputFailure)({ command: "help", options: parsed.globalOptions }, (0, errors_1.cliError)("INVALID_ARGUMENT", `Unknown help topic: ${parsed.helpTarget}`, {
+                availableCommands: (0, help_1.buildHelpText)(parsed.helpTarget).split("\n").slice(2),
+            }));
+            return;
+        }
+        printHelp(parsed.helpTarget);
         process.exit(0);
     }
-    if (parsed.command === "version") {
-        printVersion();
+    if (!parsed.command) {
+        printHelp();
         process.exit(0);
     }
     const ctx = {
@@ -85,17 +113,34 @@ function main() {
 /**
  * Dispatches a parsed CLI command into the application layer.
  */
-async function executeCommand(ctx, parsed) {
+async function executeCommand(ctx, parsed, runtime = (0, prompt_1.createPromptRuntime)()) {
     const paths = (0, codex_paths_1.createCodexPaths)(ctx.options.codexDir);
     switch (ctx.command) {
         case "list":
             return (0, list_providers_1.listProviders)(paths.providersPath);
+        case "show": {
+            let providerName = parsed.positionals[0] ?? null;
+            if (!providerName && (0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                providerName = await (0, interactive_1.promptForProviderSelection)(runtime, paths.providersPath, "Choose a provider to show");
+            }
+            if (!providerName) {
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "Missing provider name for show command.");
+            }
+            return (0, show_provider_1.showProvider)({
+                providersPath: paths.providersPath,
+                providerName,
+                includeSecret: ctx.options.json,
+            });
+        }
         case "current":
             return (0, get_current_profile_1.getCurrentProfile)(paths.configPath);
         case "status":
             return (0, get_status_1.getStatus)(paths.codexDir, paths.configPath, paths.providersPath);
         case "switch": {
-            const providerName = parsed.positionals[0];
+            let providerName = parsed.positionals[0] ?? null;
+            if (!providerName && (0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                providerName = await (0, interactive_1.promptForProviderSelection)(runtime, paths.providersPath, "Choose a provider to switch to");
+            }
             if (!providerName) {
                 throw (0, errors_1.cliError)("PROVIDER_NOT_FOUND", "Missing provider name for switch command.");
             }
@@ -113,7 +158,11 @@ async function executeCommand(ctx, parsed) {
         case "import": {
             const sourceFile = parsed.positionals[0];
             if (!sourceFile) {
-                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "Missing import file path.");
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "Missing import file path.");
+            }
+            const merge = (0, args_1.hasFlag)(parsed.commandOptions, "--merge");
+            if ((0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                await (0, interactive_1.confirmImport)(runtime, sourceFile, merge);
             }
             return (0, import_providers_1.importProviders)({
                 codexDir: paths.codexDir,
@@ -121,30 +170,103 @@ async function executeCommand(ctx, parsed) {
                 latestBackupPath: paths.latestBackupPath,
                 providersPath: paths.providersPath,
                 sourceFile,
+                merge,
             });
         }
         case "export": {
             const targetFile = parsed.positionals[0];
             if (!targetFile) {
-                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "Missing export file path.");
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "Missing export file path.");
+            }
+            let force = (0, args_1.hasFlag)(parsed.commandOptions, "--force");
+            if (!force && (0, interactive_1.canPrompt)(runtime, ctx.options.json) && (0, interactive_1.exportTargetExists)(targetFile)) {
+                const confirmed = await (0, interactive_1.confirmExportOverwrite)(runtime, targetFile);
+                if (!confirmed) {
+                    throw (0, errors_1.cliError)("PROMPT_CANCELLED", "Export cancelled.");
+                }
+                force = true;
             }
             return (0, export_providers_1.exportProviders)({
                 providersPath: paths.providersPath,
                 targetFile,
-                force: (0, args_1.hasFlag)(parsed.commandOptions, "--force"),
+                force,
             });
         }
         case "add": {
-            const providerName = parsed.positionals[0];
+            let providerName = parsed.positionals[0] ?? null;
+            let profile = (0, args_1.getSingleOption)(parsed.commandOptions, "--profile");
+            let apiKey = (0, args_1.getSingleOption)(parsed.commandOptions, "--api-key");
+            let baseUrl = (0, args_1.getSingleOption)(parsed.commandOptions, "--base-url", false);
+            let note = (0, args_1.getSingleOption)(parsed.commandOptions, "--note", false);
+            let tags = parsed.commandOptions.get("--tag") ?? [];
+            if (!providerName || !profile || !apiKey) {
+                if (ctx.options.json || !runtime.isInteractive()) {
+                    throw (0, add_interactive_1.createNonInteractiveAddError)();
+                }
+                const prompted = await (0, add_interactive_1.collectAddInput)(runtime, {
+                    providerName,
+                    profile,
+                    apiKey,
+                    baseUrl,
+                    note,
+                    tags,
+                }, (candidate) => Boolean((0, providers_repo_1.readProvidersFileIfExists)(paths.providersPath).providers[candidate]));
+                providerName = prompted.providerName;
+                profile = prompted.profile;
+                apiKey = prompted.apiKey;
+                baseUrl = prompted.baseUrl ?? null;
+                note = prompted.note ?? null;
+                tags = prompted.tags;
+            }
+            return (0, add_provider_1.addProvider)({
+                codexDir: paths.codexDir,
+                backupsDir: paths.backupsDir,
+                latestBackupPath: paths.latestBackupPath,
+                providersPath: paths.providersPath,
+                providerName,
+                profile,
+                apiKey,
+                baseUrl,
+                note,
+                tags,
+            });
+        }
+        case "edit": {
+            let providerName = parsed.positionals[0] ?? null;
+            if (!providerName && (0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                providerName = await (0, interactive_1.promptForProviderSelection)(runtime, paths.providersPath, "Choose a provider to edit");
+            }
             if (!providerName) {
-                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "Missing provider name for add command.");
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "Missing provider name for edit command.");
             }
-            const profile = (0, args_1.getSingleOption)(parsed.commandOptions, "--profile");
-            const apiKey = (0, args_1.getSingleOption)(parsed.commandOptions, "--api-key");
-            if (!profile || !apiKey) {
-                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "add requires --profile and --api-key.");
+            let profile = (0, args_1.getSingleOption)(parsed.commandOptions, "--profile", false) ?? undefined;
+            let apiKey = (0, args_1.getSingleOption)(parsed.commandOptions, "--api-key", false) ?? undefined;
+            let baseUrl = (0, args_1.getSingleOption)(parsed.commandOptions, "--base-url", false) ?? undefined;
+            let note = (0, args_1.getSingleOption)(parsed.commandOptions, "--note", false) ?? undefined;
+            let tags = parsed.commandOptions.has("--tag")
+                ? parsed.commandOptions.get("--tag") ?? []
+                : undefined;
+            if (profile === undefined &&
+                apiKey === undefined &&
+                baseUrl === undefined &&
+                note === undefined &&
+                tags === undefined &&
+                (0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                const provider = (0, providers_repo_1.readProvidersFileIfExists)(paths.providersPath).providers[providerName];
+                if (!provider) {
+                    throw (0, errors_1.cliError)("PROVIDER_NOT_FOUND", `Provider "${providerName}" was not found.`);
+                }
+                const prompted = await (0, interactive_1.collectEditInput)(runtime, provider);
+                profile = prompted.profile;
+                apiKey = prompted.apiKey;
+                baseUrl = prompted.baseUrl;
+                note = prompted.note;
+                tags = prompted.tags;
             }
-            return (0, add_provider_1.addProvider)({
+            if (profile === undefined && apiKey === undefined && baseUrl === undefined && note === undefined && tags === undefined) {
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "edit requires at least one field to update.");
+            }
+            return (0, edit_provider_1.editProvider)({
                 codexDir: paths.codexDir,
                 backupsDir: paths.backupsDir,
                 latestBackupPath: paths.latestBackupPath,
@@ -152,18 +274,25 @@ async function executeCommand(ctx, parsed) {
                 providerName,
                 profile,
                 apiKey,
-                baseUrl: (0, args_1.getSingleOption)(parsed.commandOptions, "--base-url", false),
-                note: (0, args_1.getSingleOption)(parsed.commandOptions, "--note", false),
-                tags: parsed.commandOptions.get("--tag") ?? [],
+                baseUrl,
+                note,
+                tags,
             });
         }
         case "remove": {
-            const providerName = parsed.positionals[0];
+            let providerName = parsed.positionals[0] ?? null;
+            const force = (0, args_1.hasFlag)(parsed.commandOptions, "--force");
+            if (!providerName && (0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                providerName = await (0, interactive_1.promptForProviderSelection)(runtime, paths.providersPath, "Choose a provider to remove");
+            }
             if (!providerName) {
                 throw (0, errors_1.cliError)("PROVIDER_NOT_FOUND", "Missing provider name for remove command.");
             }
-            if (!(0, args_1.hasFlag)(parsed.commandOptions, "--force")) {
-                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "remove requires --force.");
+            if (!force && !(0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "remove requires --force.");
+            }
+            if ((0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                await (0, interactive_1.confirmProviderRemoval)(runtime, providerName);
             }
             return (0, remove_provider_1.removeProvider)({
                 codexDir: paths.codexDir,
@@ -179,10 +308,58 @@ async function executeCommand(ctx, parsed) {
                 configPath: paths.configPath,
                 providersPath: paths.providersPath,
             });
+        case "setup": {
+            const overwrite = (0, args_1.hasFlag)(parsed.commandOptions, "--overwrite");
+            const merge = (0, args_1.hasFlag)(parsed.commandOptions, "--merge");
+            if (overwrite && merge) {
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "setup does not allow both --merge and --overwrite.");
+            }
+            let strategy = overwrite ? "overwrite" : merge ? "merge" : null;
+            const providersExists = fs.existsSync(paths.providersPath);
+            if (providersExists && strategy === null) {
+                if (!(0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                    throw (0, errors_1.cliError)("PROVIDERS_ALREADY_EXISTS", "providers.json already exists. Pass --merge or --overwrite.", {
+                        file: paths.providersPath,
+                    });
+                }
+                const selected = await (0, interactive_1.chooseSetupStrategy)(runtime);
+                if (selected === "cancel") {
+                    throw (0, errors_1.cliError)("PROMPT_CANCELLED", "Setup cancelled.");
+                }
+                strategy = selected;
+            }
+            const profiles = Array.from((0, config_repo_1.listConfigProfiles)(paths.configPath)).sort();
+            let providerDetailsByProfile = {};
+            if ((0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                providerDetailsByProfile = await (0, interactive_1.collectSetupProviderDetails)(runtime, profiles);
+            }
+            return (0, setup_codex_1.setupCodex)({
+                codexDirOption: ctx.options.codexDir,
+                codexDir: paths.codexDir,
+                configPath: paths.configPath,
+                providersPath: paths.providersPath,
+                backupsDir: paths.backupsDir,
+                latestBackupPath: paths.latestBackupPath,
+                strategy: strategy ?? "overwrite",
+                providerDetailsByProfile,
+            });
+        }
+        case "backups-list":
+            return (0, list_backups_1.listBackupEntries)(paths.backupsDir);
         case "rollback":
-            return (0, rollback_latest_1.rollbackLatest)(paths.latestBackupPath);
+            if (parsed.positionals.length > 1) {
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "rollback accepts at most one backup id.");
+            }
+            if ((0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                await (0, interactive_1.confirmRollback)(runtime, paths.latestBackupPath, paths.backupsDir, parsed.positionals[0] ?? null);
+            }
+            return (0, rollback_backup_1.rollbackBackup)({
+                latestBackupPath: paths.latestBackupPath,
+                backupsDir: paths.backupsDir,
+                backupId: parsed.positionals[0] ?? null,
+            });
         default:
-            throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", `Unknown command: ${ctx.command}`);
+            throw (0, errors_1.cliError)("UNKNOWN_COMMAND", `Unknown command: ${ctx.command}`);
     }
 }
 if (require.main === module) {

package/dist/domain/backups.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBackupId = getBackupId;
+exports.validateBackupManifest = validateBackupManifest;
+exports.sortBackupList = sortBackupList;
+exports.toBackupListItem = toBackupListItem;
+const path = __importStar(require("node:path"));
+/**
+ * Returns the explicit backup identifier derived from the backup directory name.
+ */
+function getBackupId(backupDir) {
+    return path.basename(backupDir);
+}
+/**
+ * Validates the minimal manifest shape needed for listing and restoring backups.
+ */
+function validateBackupManifest(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error("Backup manifest must be an object.");
+    }
+    const manifest = input;
+    if (manifest.version !== 1) {
+        throw new Error("Unsupported backup manifest version.");
+    }
+    if (typeof manifest.createdAt !== "string" || manifest.createdAt.trim() === "") {
+        throw new Error("Backup manifest is missing createdAt.");
+    }
+    if (typeof manifest.reason !== "string" || manifest.reason.trim() === "") {
+        throw new Error("Backup manifest is missing reason.");
+    }
+    if (typeof manifest.rootDir !== "string" || manifest.rootDir.trim() === "") {
+        throw new Error("Backup manifest is missing rootDir.");
+    }
+    if (typeof manifest.backupDir !== "string" || manifest.backupDir.trim() === "") {
+        throw new Error("Backup manifest is missing backupDir.");
+    }
+    if (!Array.isArray(manifest.files)) {
+        throw new Error("Backup manifest is missing files.");
+    }
+    for (const entry of manifest.files) {
+        if (!entry || typeof entry !== "object") {
+            throw new Error("Backup manifest contains an invalid file entry.");
+        }
+        if (typeof entry.relativePath !== "string" || typeof entry.existed !== "boolean") {
+            throw new Error("Backup manifest contains an invalid file entry.");
+        }
+        if (entry.backupFileName !== null && typeof entry.backupFileName !== "string") {
+            throw new Error("Backup manifest contains an invalid backup file name.");
+        }
+    }
+    return manifest;
+}
+/**
+ * Sorts backup list items from newest to oldest based on createdAt.
+ */
+function sortBackupList(items) {
+    return [...items].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+}
+/**
+ * Converts a manifest into the stable list payload returned by `backups list`.
+ */
+function toBackupListItem(manifest) {
+    return {
+        backupId: getBackupId(manifest.backupDir),
+        createdAt: manifest.createdAt,
+        reason: manifest.reason,
+        files: manifest.files.map((file) => file.relativePath),
+        backupPath: manifest.backupDir,
+    };
+}

package/dist/domain/errors.js

@@ -18,19 +18,19 @@ function normalizeError(error) {
     if (error && typeof error === "object" && "code" in error && "message" in error) {
         const candidate = error;
         return {
-            code: candidate.code ?? "INVALID_IMPORT_FILE",
+            code: candidate.code ?? "INVALID_ARGUMENT",
             message: candidate.message ?? "Unknown error.",
             details: candidate.details,
         };
     }
     if (error instanceof Error) {
         return {
-            code: "INVALID_IMPORT_FILE",
+            code: "INVALID_ARGUMENT",
             message: error.message,
         };
     }
     return {
-        code: "INVALID_IMPORT_FILE",
+        code: "INVALID_ARGUMENT",
         message: String(error),
     };
 }

package/dist/domain/providers.js

@@ -4,6 +4,7 @@ exports.validateProvidersShape = validateProvidersShape;
 exports.cleanProviderRecord = cleanProviderRecord;
 exports.sortProviders = sortProviders;
 exports.findProviderByProfile = findProviderByProfile;
+exports.maskSecret = maskSecret;
 /**
  * Validates and normalizes unknown JSON into the providers.json domain model.
  */
@@ -90,3 +91,12 @@ function findProviderByProfile(providers, profile) {
     }
     return null;
 }
+/**
+ * Masks a secret for human-readable output while preserving a short fingerprint.
+ */
+function maskSecret(value) {
+    if (value.length <= 5) {
+        return "*".repeat(Math.max(value.length, 1));
+    }
+    return `${value.slice(0, 3)}***${value.slice(-2)}`;
+}

package/dist/domain/setup.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSetupDrafts = buildSetupDrafts;
+exports.findIncompleteSetupProfiles = findIncompleteSetupProfiles;
+const providers_1 = require("./providers");
+/**
+ * Creates initial provider drafts from config profile names.
+ */
+function buildSetupDrafts(profiles, detailsByProfile) {
+    return profiles.map((profile) => {
+        const detail = detailsByProfile[profile] ?? {};
+        const providerName = (detail.providerName ?? profile).trim();
+        return {
+            providerName,
+            record: (0, providers_1.cleanProviderRecord)({
+                profile,
+                apiKey: detail.apiKey ?? "",
+                baseUrl: detail.baseUrl,
+                note: detail.note,
+                tags: detail.tags,
+            }),
+        };
+    });
+}
+/**
+ * Returns the profile names that still lack required provider fields.
+ */
+function findIncompleteSetupProfiles(drafts) {
+    return drafts.filter((draft) => draft.record.apiKey.trim() === "").map((draft) => draft.record.profile);
+}

package/dist/infra/backup-repo.js

@@ -37,8 +37,11 @@ exports.createBackup = createBackup;
 exports.restoreManifest = restoreManifest;
 exports.saveLatestManifest = saveLatestManifest;
 exports.loadLatestManifest = loadLatestManifest;
+exports.loadManifestById = loadManifestById;
+exports.listBackups = listBackups;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const backups_1 = require("../domain/backups");
 const errors_1 = require("../domain/errors");
 const fs_utils_1 = require("./fs-utils");
 /**
@@ -115,16 +118,12 @@ function saveLatestManifest(latestBackupPath, manifest) {
  */
 function loadLatestManifest(latestBackupPath) {
     if (!fs.existsSync(latestBackupPath)) {
-        throw (0, errors_1.cliError)("ROLLBACK_FAILED", "No rollback backup is available.", {
+        throw (0, errors_1.cliError)("BACKUP_NOT_FOUND", "No rollback backup is available.", {
             file: latestBackupPath,
         });
     }
     try {
-        const manifest = JSON.parse(fs.readFileSync(latestBackupPath, "utf8"));
-        if (!manifest || typeof manifest !== "object" || !Array.isArray(manifest.files)) {
-            throw new Error("Invalid latest backup manifest.");
-        }
-        return manifest;
+        return (0, backups_1.validateBackupManifest)(JSON.parse(fs.readFileSync(latestBackupPath, "utf8")));
     }
     catch (error) {
         throw (0, errors_1.cliError)("ROLLBACK_FAILED", "Failed to read latest backup manifest.", {
@@ -133,6 +132,66 @@ function loadLatestManifest(latestBackupPath) {
         });
     }
 }
+/**
+ * Loads a backup manifest by its explicit backup id.
+ */
+function loadManifestById(backupsDir, backupId) {
+    const manifestPath = path.join(backupsDir, backupId, "manifest.json");
+    if (!fs.existsSync(manifestPath)) {
+        throw (0, errors_1.cliError)("BACKUP_NOT_FOUND", `Backup "${backupId}" was not found.`, {
+            backupId,
+            file: manifestPath,
+        });
+    }
+    try {
+        return (0, backups_1.validateBackupManifest)(JSON.parse(fs.readFileSync(manifestPath, "utf8")));
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("ROLLBACK_FAILED", `Failed to read backup manifest "${backupId}".`, {
+            backupId,
+            file: manifestPath,
+            cause: (0, errors_1.normalizeError)(error).message,
+        });
+    }
+}
+/**
+ * Lists valid backup manifests under backups/, newest first, while skipping corrupt entries with warnings.
+ */
+function listBackups(backupsDir) {
+    if (!fs.existsSync(backupsDir)) {
+        throw (0, errors_1.cliError)("BACKUP_NOT_FOUND", "No backups directory exists.", {
+            directory: backupsDir,
+        });
+    }
+    const entries = fs.readdirSync(backupsDir, { withFileTypes: true });
+    const backups = [];
+    const warnings = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === "latest.json") {
+            continue;
+        }
+        const manifestPath = path.join(backupsDir, entry.name, "manifest.json");
+        if (!fs.existsSync(manifestPath)) {
+            warnings.push(`Skipped backup "${entry.name}" because manifest.json is missing.`);
+            continue;
+        }
+        try {
+            backups.push((0, backups_1.toBackupListItem)((0, backups_1.validateBackupManifest)(JSON.parse(fs.readFileSync(manifestPath, "utf8")))));
+        }
+        catch (error) {
+            warnings.push(`Skipped backup "${entry.name}" because manifest.json is invalid: ${(0, errors_1.normalizeError)(error).message}`);
+        }
+    }
+    if (backups.length === 0) {
+        throw (0, errors_1.cliError)("BACKUP_NOT_FOUND", "No valid backups were found.", {
+            directory: backupsDir,
+        });
+    }
+    return {
+        backups: (0, backups_1.sortBackupList)(backups),
+        warnings,
+    };
+}
 /**
  * Formats a filesystem-safe timestamp for backup directory names.
  */