@minniexcode/codex-switch 0.0.2 → 0.0.4

package/dist/app/import-providers.js

@@ -65,9 +65,18 @@ function importProviders(args) {
         operation: "import",
         files: [{ absolutePath: args.providersPath, relativePath: "providers.json" }],
         mutate: () => {
-            (0, providers_repo_1.writeProvidersFile)(args.providersPath, imported);
+            const current = (0, providers_repo_1.readProvidersFileIfExists)(args.providersPath);
+            const next = args.merge ? (0, providers_repo_1.mergeProviders)(current, imported) : imported;
+            (0, providers_repo_1.writeProvidersFile)(args.providersPath, next);
+            const replacedProviders = args.merge
+                ? Object.keys(imported.providers).filter((name) => current.providers[name]).sort()
+                : [];
             return {
+                mode: args.merge ? "merge" : "replace",
                 importedProviders: Object.keys(imported.providers).sort(),
+                importedCount: Object.keys(imported.providers).length,
+                mergedCount: Object.keys(next.providers).length,
+                replacedProviders,
             };
         },
     });

package/dist/app/list-backups.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listBackupEntries = listBackupEntries;
+const backup_repo_1 = require("../infra/backup-repo");
+/**
+ * Lists backup manifests available under the managed Codex backups directory.
+ */
+function listBackupEntries(backupsDir) {
+    const result = (0, backup_repo_1.listBackups)(backupsDir);
+    return {
+        data: {
+            backups: result.backups,
+            count: result.backups.length,
+        },
+        warnings: result.warnings,
+    };
+}

package/dist/app/rollback-backup.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rollbackBackup = rollbackBackup;
+const errors_1 = require("../domain/errors");
+const backup_repo_1 = require("../infra/backup-repo");
+/**
+ * Restores either the latest backup or a specific historical backup by id.
+ */
+function rollbackBackup(args) {
+    const manifest = args.backupId
+        ? (0, backup_repo_1.loadManifestById)(args.backupsDir, args.backupId)
+        : (0, backup_repo_1.loadLatestManifest)(args.latestBackupPath);
+    try {
+        (0, backup_repo_1.restoreManifest)(manifest);
+        return {
+            data: {
+                restoredFiles: manifest.files.map((file) => file.relativePath),
+                backupId: args.backupId ?? null,
+                backupPath: manifest.backupDir,
+            },
+        };
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("ROLLBACK_FAILED", "Rollback failed.", {
+            cause: (0, errors_1.normalizeError)(error).message,
+            backupPath: manifest.backupDir,
+            backupId: args.backupId ?? null,
+        });
+    }
+}

package/dist/app/setup-codex.js

@@ -0,0 +1,138 @@
+"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.setupCodex = setupCodex;
+const fs = __importStar(require("node:fs"));
+const setup_1 = require("../domain/setup");
+const errors_1 = require("../domain/errors");
+const codex_discovery_1 = require("../infra/codex-discovery");
+const codex_cli_1 = require("../infra/codex-cli");
+const config_repo_1 = require("../infra/config-repo");
+const fs_utils_1 = require("../infra/fs-utils");
+const providers_repo_1 = require("../infra/providers-repo");
+const run_doctor_1 = require("./run-doctor");
+const run_mutation_1 = require("./run-mutation");
+const MIN_CODEX_VERSION = "0.0.1";
+/**
+ * Bootstraps a managed providers.json from the existing Codex directory.
+ */
+function setupCodex(args) {
+    const available = (0, codex_cli_1.checkCodexAvailable)();
+    if (!available.ok) {
+        throw (0, errors_1.cliError)("CODEX_NOT_INSTALLED", "codex CLI is not available.", {
+            cause: available.cause,
+        });
+    }
+    const version = (0, codex_cli_1.checkCodexVersion)(MIN_CODEX_VERSION);
+    if (!version.ok) {
+        throw (0, errors_1.cliError)("CODEX_VERSION_UNSUPPORTED", "codex CLI version is below the supported minimum.", {
+            minimumVersion: MIN_CODEX_VERSION,
+            currentVersion: version.currentVersion ?? null,
+            cause: version.cause,
+        });
+    }
+    const candidates = (0, codex_discovery_1.findCodexDirCandidates)(args.codexDirOption);
+    if (candidates.length === 0) {
+        throw (0, errors_1.cliError)("CODEX_DIR_NOT_FOUND", "No Codex directory could be found.", {
+            codexDir: args.codexDir,
+        });
+    }
+    if (candidates.length > 1) {
+        throw (0, errors_1.cliError)("CODEX_DIR_AMBIGUOUS", "Multiple Codex directories were found.", {
+            candidates,
+        });
+    }
+    if (!fs.existsSync(args.codexDir)) {
+        throw (0, errors_1.cliError)("CODEX_DIR_NOT_FOUND", "The requested Codex directory does not exist.", {
+            codexDir: args.codexDir,
+        });
+    }
+    const profiles = Array.from((0, config_repo_1.listConfigProfiles)(args.configPath)).sort();
+    if (profiles.length === 0) {
+        throw (0, errors_1.cliError)("PROFILE_NOT_FOUND", "No profiles were found in config.toml.", {
+            file: args.configPath,
+        });
+    }
+    const drafts = (0, setup_1.buildSetupDrafts)(profiles, args.providerDetailsByProfile);
+    const incompleteProfiles = (0, setup_1.findIncompleteSetupProfiles)(drafts);
+    if (incompleteProfiles.length > 0) {
+        throw (0, errors_1.cliError)("INVALID_ARGUMENT", "setup requires complete provider data for every selected profile.", {
+            incompleteProfiles,
+        });
+    }
+    (0, fs_utils_1.ensureDir)(args.codexDir);
+    const currentProviders = (0, providers_repo_1.readProvidersFileIfExists)(args.providersPath);
+    const providersExists = fs.existsSync(args.providersPath);
+    if (providersExists && args.strategy !== "merge" && args.strategy !== "overwrite") {
+        throw (0, errors_1.cliError)("PROVIDERS_ALREADY_EXISTS", "providers.json already exists.", {
+            file: args.providersPath,
+        });
+    }
+    const nextProviders = {
+        providers: drafts.reduce((accumulator, draft) => {
+            accumulator[draft.providerName] = draft.record;
+            return accumulator;
+        }, {}),
+    };
+    const finalProviders = args.strategy === "merge" ? (0, providers_repo_1.mergeProviders)(currentProviders, nextProviders) : nextProviders;
+    const result = (0, run_mutation_1.runMutation)({
+        codexDir: args.codexDir,
+        backupsDir: args.backupsDir,
+        latestBackupPath: args.latestBackupPath,
+        operation: "setup",
+        files: [{ absolutePath: args.providersPath, relativePath: "providers.json" }],
+        mutate: () => {
+            (0, providers_repo_1.writeProvidersFile)(args.providersPath, finalProviders);
+            return {
+                codexDir: args.codexDir,
+                strategy: args.strategy,
+                providersInitialized: Object.keys(nextProviders.providers).length,
+                providerNames: Object.keys(finalProviders.providers).sort(),
+            };
+        },
+    });
+    const doctor = (0, run_doctor_1.runDoctor)({
+        codexDir: args.codexDir,
+        configPath: args.configPath,
+        providersPath: args.providersPath,
+    });
+    return {
+        data: {
+            ...result.data,
+            doctor: doctor.data,
+        },
+        warnings: doctor.warnings,
+    };
+}

package/dist/app/show-provider.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showProvider = showProvider;
+const providers_1 = require("../domain/providers");
+const providers_repo_1 = require("../infra/providers-repo");
+/**
+ * Returns a single provider record, with text-mode callers able to use a masked preview.
+ */
+function showProvider(args) {
+    const provider = (0, providers_repo_1.readProviderRecord)(args.providersPath, args.providerName);
+    return {
+        data: {
+            providerName: args.providerName,
+            provider: args.includeSecret
+                ? provider
+                : {
+                    ...provider,
+                    apiKey: (0, providers_1.maskSecret)(provider.apiKey),
+                },
+        },
+    };
+}

package/dist/cli/add-interactive.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMON_TAG_CHOICES = void 0;
+exports.collectAddInput = collectAddInput;
+exports.createNonInteractiveAddError = createNonInteractiveAddError;
+exports.promptTags = promptTags;
+exports.parseTags = parseTags;
+const errors_1 = require("../domain/errors");
+exports.COMMON_TAG_CHOICES = ["free", "paid", "daily", "backup"];
+/**
+ * Collects add command inputs interactively when required values are missing.
+ */
+async function collectAddInput(runtime, defaults, providerExists) {
+    runtime.writeLine("Interactive add mode");
+    runtime.writeLine("Provide the missing required fields. Press Enter to skip optional fields.");
+    const providerName = defaults.providerName
+        ? normalizeRequiredValue(defaults.providerName)
+        : await promptProviderName(runtime, providerExists);
+    const profile = defaults.profile ? normalizeRequiredValue(defaults.profile) : await promptRequiredValue(runtime, "Profile");
+    const apiKey = defaults.apiKey
+        ? normalizeRequiredValue(defaults.apiKey)
+        : await promptConfirmedSecret(runtime, "API key", "Confirm API key");
+    const baseUrl = defaults.baseUrl ?? normalizeOptionalValue(await runtime.inputText("Base URL (optional)"));
+    const note = defaults.note ?? normalizeOptionalValue(await runtime.inputText("Note (optional)"));
+    const tags = defaults.tags.length > 0 ? defaults.tags : await promptTags(runtime);
+    return {
+        providerName,
+        profile,
+        apiKey,
+        baseUrl,
+        note,
+        tags,
+    };
+}
+/**
+ * Throws a consistent error when interactive add is unavailable.
+ */
+function createNonInteractiveAddError() {
+    return (0, errors_1.cliError)("INVALID_ARGUMENT", "add requires <provider>, --profile, and --api-key when running without an interactive TTY.", {
+        suggestion: "Run in a terminal TTY or pass all required values explicitly.",
+    });
+}
+async function promptProviderName(runtime, providerExists) {
+    while (true) {
+        const providerName = await promptRequiredValue(runtime, "Provider name");
+        if (providerExists(providerName)) {
+            runtime.writeLine(`Provider "${providerName}" already exists. Choose a different name.`);
+            continue;
+        }
+        return providerName;
+    }
+}
+async function promptRequiredValue(runtime, label) {
+    while (true) {
+        const value = normalizeRequiredValue(await runtime.inputText(label));
+        if (value.length > 0) {
+            return value;
+        }
+        runtime.writeLine(`${label} is required.`);
+    }
+}
+async function promptConfirmedSecret(runtime, label, confirmationLabel) {
+    while (true) {
+        const first = normalizeRequiredValue(await runtime.inputSecret(label));
+        if (first.length === 0) {
+            runtime.writeLine(`${label} is required.`);
+            continue;
+        }
+        const second = normalizeRequiredValue(await runtime.inputSecret(confirmationLabel));
+        if (second.length === 0) {
+            runtime.writeLine(`${confirmationLabel} is required.`);
+            continue;
+        }
+        if (first !== second) {
+            runtime.writeLine("API key entries did not match. Try again.");
+            continue;
+        }
+        return first;
+    }
+}
+function normalizeRequiredValue(value) {
+    return value.trim();
+}
+function normalizeOptionalValue(value) {
+    const normalized = value.trim();
+    return normalized === "" ? null : normalized;
+}
+async function promptTags(runtime, defaults = []) {
+    const defaultPresetTags = defaults.filter(isCommonTag);
+    const defaultCustomTags = defaults.filter((tag) => !isCommonTag(tag));
+    const presetTags = await runtime.selectMany("Select tags (optional)", exports.COMMON_TAG_CHOICES.map((tag) => ({ value: tag, label: tag })), { defaultValues: defaultPresetTags });
+    const customTags = parseTags(await runtime.inputText("Custom tags (optional, comma-separated)", {
+        defaultValue: defaultCustomTags.join(", "),
+    }));
+    return dedupeTags([...presetTags, ...customTags]);
+}
+function parseTags(value) {
+    return dedupeTags(value
+        .split(",")
+        .map((tag) => tag.trim())
+        .filter((tag) => tag.length > 0));
+}
+function isCommonTag(tag) {
+    return exports.COMMON_TAG_CHOICES.includes(tag);
+}
+function dedupeTags(tags) {
+    return Array.from(new Set(tags));
+}

package/dist/cli/args.js

@@ -9,12 +9,6 @@ const codex_paths_1 = require("../infra/codex-paths");
  * Parses argv into command positionals, global flags, and command-scoped options.
  */
 function parseArgs(argv) {
-    if (argv.includes("--help") || argv.includes("-h")) {
-        return defaultParsed("help");
-    }
-    if (argv.includes("--version") || argv.includes("-v")) {
-        return defaultParsed("version");
-    }
     let json = false;
     let codexDir = (0, codex_paths_1.resolveCodexDir)();
     const remaining = [];
@@ -27,7 +21,7 @@ function parseArgs(argv) {
         if (value === "--codex-dir") {
             const next = argv[index + 1];
             if (!next) {
-                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "--codex-dir requires a path value.");
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "--codex-dir requires a path value.");
             }
             codexDir = (0, codex_paths_1.resolveCodexDir)(next);
             index += 1;
@@ -35,11 +29,41 @@ function parseArgs(argv) {
         }
         remaining.push(value);
     }
-    const command = remaining[0] ?? null;
+    if (remaining[0] === "help") {
+        const helpTarget = remaining[1] === "backups" && remaining[2] === "list" ? "backups" : remaining[1] ?? null;
+        return {
+            command: null,
+            positionals: [],
+            globalOptions: {
+                json,
+                codexDir,
+            },
+            commandOptions: new Map(),
+            helpRequested: true,
+            helpTarget,
+            versionRequested: false,
+        };
+    }
+    const versionRequested = remaining.includes("--version") || remaining.includes("-v");
+    if (versionRequested) {
+        return defaultParsed(null, {
+            json,
+            codexDir,
+            versionRequested: true,
+        });
+    }
+    const commandToken = remaining[0] ?? null;
+    const command = commandToken === "backups" && remaining[1] === "list" ? "backups-list" : commandToken;
     const positionals = [];
     const commandOptions = new Map();
-    for (let index = 1; index < remaining.length; index += 1) {
+    let helpRequested = false;
+    const startIndex = command === "backups-list" ? 2 : 1;
+    for (let index = startIndex; index < remaining.length; index += 1) {
         const value = remaining[index];
+        if (value === "--help" || value === "-h") {
+            helpRequested = true;
+            continue;
+        }
         if (value.startsWith("--")) {
             const optionName = value;
             const next = remaining[index + 1];
@@ -64,20 +88,26 @@ function parseArgs(argv) {
             codexDir,
         },
         commandOptions,
+        helpRequested,
+        helpTarget: helpRequested ? (command === "backups-list" ? "backups" : command) : null,
+        versionRequested: false,
     };
 }
 /**
  * Creates a parsed result for built-in synthetic commands such as help/version.
  */
-function defaultParsed(command) {
+function defaultParsed(command, overrides) {
     return {
         command,
         positionals: [],
         globalOptions: {
-            json: false,
-            codexDir: (0, codex_paths_1.resolveCodexDir)(),
+            json: overrides?.json ?? false,
+            codexDir: overrides?.codexDir ?? (0, codex_paths_1.resolveCodexDir)(),
         },
         commandOptions: new Map(),
+        helpRequested: overrides?.helpRequested ?? false,
+        helpTarget: overrides?.helpTarget ?? null,
+        versionRequested: overrides?.versionRequested ?? false,
     };
 }
 /**