@minniexcode/codex-switch 0.0.3 → 0.0.4

package/dist/cli.js

@@ -1,20 +1,59 @@
 #!/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");
@@ -23,7 +62,7 @@ const help_1 = require("./cli/help");
 const interactive_1 = require("./cli/interactive");
 const output_1 = require("./cli/output");
 const prompt_1 = require("./cli/prompt");
-const VERSION = "0.0.3";
+const VERSION = "0.0.4";
 /**
  * Prints the command help text to stdout.
  */
@@ -47,7 +86,7 @@ function main() {
     }
     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_IMPORT_FILE", `Unknown help topic: ${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;
@@ -79,6 +118,20 @@ async function executeCommand(ctx, parsed, runtime = (0, prompt_1.createPromptRu
     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":
@@ -105,10 +158,11 @@ async function executeCommand(ctx, parsed, runtime = (0, prompt_1.createPromptRu
         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);
+                await (0, interactive_1.confirmImport)(runtime, sourceFile, merge);
             }
             return (0, import_providers_1.importProviders)({
                 codexDir: paths.codexDir,
@@ -116,18 +170,19 @@ async function executeCommand(ctx, parsed, runtime = (0, prompt_1.createPromptRu
                 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)("INVALID_IMPORT_FILE", "Export cancelled.");
+                    throw (0, errors_1.cliError)("PROMPT_CANCELLED", "Export cancelled.");
                 }
                 force = true;
             }
@@ -155,7 +210,7 @@ async function executeCommand(ctx, parsed, runtime = (0, prompt_1.createPromptRu
                     baseUrl,
                     note,
                     tags,
-                }, (candidate) => Boolean((0, providers_repo_1.readProvidersFileIfExists)(paths.providersPath).providers[candidate]), paths.configPath);
+                }, (candidate) => Boolean((0, providers_repo_1.readProvidersFileIfExists)(paths.providersPath).providers[candidate]));
                 providerName = prompted.providerName;
                 profile = prompted.profile;
                 apiKey = prompted.apiKey;
@@ -176,6 +231,54 @@ async function executeCommand(ctx, parsed, runtime = (0, prompt_1.createPromptRu
                 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_ARGUMENT", "Missing provider name for edit command.");
+            }
+            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;
+            }
+            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,
+                providersPath: paths.providersPath,
+                providerName,
+                profile,
+                apiKey,
+                baseUrl,
+                note,
+                tags,
+            });
+        }
         case "remove": {
             let providerName = parsed.positionals[0] ?? null;
             const force = (0, args_1.hasFlag)(parsed.commandOptions, "--force");
@@ -186,7 +289,7 @@ async function executeCommand(ctx, parsed, runtime = (0, prompt_1.createPromptRu
                 throw (0, errors_1.cliError)("PROVIDER_NOT_FOUND", "Missing provider name for remove command.");
             }
             if (!force && !(0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
-                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "remove requires --force.");
+                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);
@@ -205,13 +308,58 @@ async function executeCommand(ctx, parsed, runtime = (0, prompt_1.createPromptRu
                 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":
+            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);
+                await (0, interactive_1.confirmRollback)(runtime, paths.latestBackupPath, paths.backupsDir, parsed.positionals[0] ?? null);
             }
-            return (0, rollback_latest_1.rollbackLatest)(paths.latestBackupPath);
+            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.
  */

package/dist/infra/codex-cli.js

@@ -4,6 +4,8 @@ exports.setCodexSpawnImplementation = setCodexSpawnImplementation;
 exports.resetCodexSpawnImplementation = resetCodexSpawnImplementation;
 exports.runCodexLogin = runCodexLogin;
 exports.checkCodexAvailable = checkCodexAvailable;
+exports.readCodexVersion = readCodexVersion;
+exports.checkCodexVersion = checkCodexVersion;
 const node_child_process_1 = require("node:child_process");
 const errors_1 = require("../domain/errors");
 let spawnImplementation = node_child_process_1.spawnSync;
@@ -51,3 +53,63 @@ function checkCodexAvailable() {
     }
     return { ok: true };
 }
+/**
+ * Reads the installed codex CLI version string.
+ */
+function readCodexVersion() {
+    const result = spawnImplementation("codex", ["--version"], {
+        stdio: "pipe",
+        encoding: "utf8",
+    });
+    if (result.error || result.status !== 0) {
+        return {
+            ok: false,
+            cause: result.error?.message ?? (result.stderr.trim() || "Unknown failure"),
+        };
+    }
+    const raw = `${result.stdout ?? ""} ${result.stderr ?? ""}`.trim();
+    const match = raw.match(/(\d+\.\d+\.\d+)/);
+    if (!match) {
+        return {
+            ok: false,
+            cause: `Unable to parse codex version from output: ${raw || "(empty output)"}`,
+        };
+    }
+    return { ok: true, version: match[1] };
+}
+/**
+ * Compares the installed codex version against a minimum required version.
+ */
+function checkCodexVersion(minVersion) {
+    const current = readCodexVersion();
+    if (!current.ok) {
+        return {
+            ok: false,
+            cause: current.cause,
+        };
+    }
+    if (compareVersions(current.version, minVersion) < 0) {
+        return {
+            ok: false,
+            currentVersion: current.version,
+            cause: `codex ${current.version} is below required ${minVersion}`,
+        };
+    }
+    return {
+        ok: true,
+        currentVersion: current.version,
+    };
+}
+function compareVersions(left, right) {
+    const leftParts = left.split(".").map((value) => Number.parseInt(value, 10));
+    const rightParts = right.split(".").map((value) => Number.parseInt(value, 10));
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = leftParts[index] ?? 0;
+        const rightValue = rightParts[index] ?? 0;
+        if (leftValue !== rightValue) {
+            return leftValue - rightValue;
+        }
+    }
+    return 0;
+}

package/dist/infra/codex-discovery.js

@@ -0,0 +1,48 @@
+"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.findCodexDirCandidates = findCodexDirCandidates;
+const fs = __importStar(require("node:fs"));
+const codex_paths_1 = require("./codex-paths");
+/**
+ * Finds candidate Codex home directories. v0.0.4 only supports explicit and default locations.
+ */
+function findCodexDirCandidates(explicitCodexDir) {
+    if (explicitCodexDir) {
+        return [(0, codex_paths_1.resolveCodexDir)(explicitCodexDir)];
+    }
+    const defaultDir = (0, codex_paths_1.resolveCodexDir)();
+    return fs.existsSync(defaultDir) ? [defaultDir] : [];
+}