@minniexcode/codex-switch 0.0.1 → 0.0.3

package/dist/app/get-status.js

@@ -0,0 +1,75 @@
+"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.getStatus = getStatus;
+const fs = __importStar(require("node:fs"));
+const config_1 = require("../domain/config");
+const runtime_state_1 = require("../domain/runtime-state");
+const providers_repo_1 = require("../infra/providers-repo");
+/**
+ * Reports the current on-disk runtime state and how it maps back to managed providers.
+ */
+function getStatus(codexDir, configPath, providersPath) {
+    const configExists = fs.existsSync(configPath);
+    const providersExists = fs.existsSync(providersPath);
+    let currentProfile = null;
+    const warnings = [];
+    const providers = providersExists ? (0, providers_repo_1.readProvidersFile)(providersPath) : null;
+    if (configExists) {
+        const configContent = fs.readFileSync(configPath, "utf8");
+        currentProfile = (0, config_1.parseTopLevelProfile)(configContent);
+        if (!currentProfile) {
+            warnings.push("config.toml exists but has no top-level profile.");
+        }
+    }
+    const liveState = (0, runtime_state_1.inspectLiveStateDrift)(currentProfile, providers);
+    if (liveState.canBackfillActiveProvider) {
+        // Surface unmanaged live state without mutating anything during a read-only status call.
+        warnings.push("Current config profile is not mapped in providers.json. Backfill would be required before treating live state as managed.");
+    }
+    return {
+        warnings,
+        data: {
+            codexDir,
+            storage: (0, runtime_state_1.getStorageRoles)(),
+            configExists,
+            providersExists,
+            currentProfile,
+            currentProfileMapped: liveState.profileMapped,
+            provider: liveState.mappedProvider,
+            liveState,
+        },
+    };
+}

package/dist/app/import-providers.js

@@ -0,0 +1,74 @@
+"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.importProviders = importProviders;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const providers_1 = require("../domain/providers");
+const errors_1 = require("../domain/errors");
+const fs_utils_1 = require("../infra/fs-utils");
+const providers_repo_1 = require("../infra/providers-repo");
+const run_mutation_1 = require("./run-mutation");
+/**
+ * Imports provider definitions from an external JSON file into the managed registry.
+ */
+function importProviders(args) {
+    const absoluteSource = path.resolve(args.sourceFile);
+    let imported;
+    try {
+        // Validate before writing so malformed imports never touch the managed file.
+        imported = (0, providers_1.validateProvidersShape)(JSON.parse(fs.readFileSync(absoluteSource, "utf8")));
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "Import file is not valid providers.json data.", {
+            file: absoluteSource,
+            cause: (0, errors_1.normalizeError)(error).message,
+        });
+    }
+    (0, fs_utils_1.ensureDir)(args.codexDir);
+    return (0, run_mutation_1.runMutation)({
+        codexDir: args.codexDir,
+        backupsDir: args.backupsDir,
+        latestBackupPath: args.latestBackupPath,
+        operation: "import",
+        files: [{ absolutePath: args.providersPath, relativePath: "providers.json" }],
+        mutate: () => {
+            (0, providers_repo_1.writeProvidersFile)(args.providersPath, imported);
+            return {
+                importedProviders: Object.keys(imported.providers).sort(),
+            };
+        },
+    });
+}

package/dist/app/list-providers.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listProviders = listProviders;
+const providers_repo_1 = require("../infra/providers-repo");
+/**
+ * Returns the sorted list of configured providers for display.
+ */
+function listProviders(providersPath) {
+    const providers = (0, providers_repo_1.readProvidersFile)(providersPath);
+    const names = Object.keys(providers.providers).sort();
+    const items = names.map((name) => ({
+        name,
+        profile: providers.providers[name].profile,
+        note: providers.providers[name].note ?? null,
+        tags: providers.providers[name].tags ?? [],
+    }));
+    return {
+        data: {
+            providers: items,
+            count: items.length,
+        },
+    };
+}

package/dist/app/remove-provider.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeProvider = removeProvider;
+const errors_1 = require("../domain/errors");
+const providers_repo_1 = require("../infra/providers-repo");
+const run_mutation_1 = require("./run-mutation");
+/**
+ * Removes a provider from the managed providers registry.
+ */
+function removeProvider(args) {
+    const providers = (0, providers_repo_1.readProvidersFile)(args.providersPath);
+    if (!providers.providers[args.providerName]) {
+        throw (0, errors_1.cliError)("PROVIDER_NOT_FOUND", `Provider "${args.providerName}" was not found.`);
+    }
+    const nextProviders = { ...providers.providers };
+    // Delete against a copied object so the original parsed state stays untouched.
+    delete nextProviders[args.providerName];
+    return (0, run_mutation_1.runMutation)({
+        codexDir: args.codexDir,
+        backupsDir: args.backupsDir,
+        latestBackupPath: args.latestBackupPath,
+        operation: "remove",
+        files: [{ absolutePath: args.providersPath, relativePath: "providers.json" }],
+        mutate: () => {
+            (0, providers_repo_1.writeProvidersFile)(args.providersPath, { providers: nextProviders });
+            return {
+                provider: args.providerName,
+            };
+        },
+    });
+}

package/dist/app/rollback-latest.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rollbackLatest = rollbackLatest;
+const errors_1 = require("../domain/errors");
+const backup_repo_1 = require("../infra/backup-repo");
+/**
+ * Restores the most recent mutation backup recorded by codex-switch.
+ */
+function rollbackLatest(latestBackupPath) {
+    const manifest = (0, backup_repo_1.loadLatestManifest)(latestBackupPath);
+    try {
+        (0, backup_repo_1.restoreManifest)(manifest);
+        return {
+            data: {
+                restoredFiles: manifest.files.map((file) => file.relativePath),
+                backupPath: manifest.backupDir,
+            },
+        };
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("ROLLBACK_FAILED", "Rollback failed.", {
+            cause: (0, errors_1.normalizeError)(error).message,
+            backupPath: manifest.backupDir,
+        });
+    }
+}

package/dist/app/run-doctor.js

@@ -0,0 +1,130 @@
+"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.runDoctor = runDoctor;
+const fs = __importStar(require("node:fs"));
+const config_1 = require("../domain/config");
+const runtime_state_1 = require("../domain/runtime-state");
+const codex_cli_1 = require("../infra/codex-cli");
+const providers_repo_1 = require("../infra/providers-repo");
+const errors_1 = require("../domain/errors");
+/**
+ * Performs consistency checks across config.toml, providers.json, and the local Codex CLI.
+ */
+function runDoctor(args) {
+    const issues = [];
+    let configProfiles = new Set();
+    let currentProfile = null;
+    let providers = null;
+    if (!fs.existsSync(args.configPath)) {
+        issues.push({
+            code: "CONFIG_NOT_FOUND",
+            message: "config.toml does not exist.",
+            file: args.configPath,
+        });
+    }
+    else {
+        const configContent = fs.readFileSync(args.configPath, "utf8");
+        configProfiles = (0, config_1.parseProfileNames)(configContent);
+        currentProfile = (0, config_1.parseTopLevelProfile)(configContent);
+        if (!currentProfile) {
+            issues.push({
+                code: "PROFILE_NOT_FOUND",
+                message: "config.toml has no top-level profile.",
+                file: args.configPath,
+            });
+        }
+    }
+    if (!fs.existsSync(args.providersPath)) {
+        issues.push({
+            code: "PROVIDERS_NOT_FOUND",
+            message: "providers.json does not exist.",
+            file: args.providersPath,
+        });
+    }
+    else {
+        try {
+            providers = (0, providers_repo_1.readProvidersFile)(args.providersPath);
+            // Every managed provider must map to a profile that still exists in config.toml.
+            for (const [name, provider] of Object.entries(providers.providers)) {
+                if (!configProfiles.has(provider.profile)) {
+                    issues.push({
+                        code: "PROFILE_NOT_FOUND",
+                        message: `Provider "${name}" maps to missing profile "${provider.profile}".`,
+                        provider: name,
+                        profile: provider.profile,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            const normalized = (0, errors_1.normalizeError)(error);
+            issues.push({
+                code: normalized.code,
+                message: normalized.message,
+                ...(normalized.details ?? {}),
+            });
+        }
+    }
+    const drift = (0, runtime_state_1.inspectLiveStateDrift)(currentProfile, providers);
+    if (drift.canBackfillActiveProvider) {
+        // Distinguish unmanaged live state from hard parse/configuration errors.
+        issues.push({
+            code: "LIVE_STATE_DRIFT",
+            message: `Active profile "${drift.currentProfile}" is present in config.toml but not mapped by providers.json.`,
+            currentProfile: drift.currentProfile,
+            suggestedAction: "backfill-active-provider",
+            storage: (0, runtime_state_1.getStorageRoles)(),
+        });
+    }
+    const codexCheck = (0, codex_cli_1.checkCodexAvailable)();
+    if (!codexCheck.ok) {
+        issues.push({
+            code: "CODEX_LOGIN_FAILED",
+            message: "codex CLI is not available.",
+            cause: codexCheck.cause,
+        });
+    }
+    return {
+        data: {
+            healthy: issues.length === 0,
+            issues,
+            codexDir: args.codexDir,
+            storage: (0, runtime_state_1.getStorageRoles)(),
+            liveState: drift,
+        },
+        warnings: issues.length === 0 ? [] : [`doctor found ${issues.length} issue(s)`],
+    };
+}

package/dist/app/run-mutation.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMutation = runMutation;
+const errors_1 = require("../domain/errors");
+const backup_repo_1 = require("../infra/backup-repo");
+const lock_repo_1 = require("../infra/lock-repo");
+/**
+ * Runs a write operation under a lock with automatic backup and rollback handling.
+ */
+function runMutation(args) {
+    return (0, lock_repo_1.withCodexLock)(args.codexDir, args.operation, () => {
+        const backup = (0, backup_repo_1.createBackup)(args.codexDir, args.backupsDir, args.operation, args.files);
+        try {
+            const data = args.mutate({ backup });
+            // Record the successful backup only after the mutation completes.
+            (0, backup_repo_1.saveLatestManifest)(args.latestBackupPath, backup);
+            return {
+                data: {
+                    ...data,
+                    backupPath: backup.backupDir,
+                    managedState: {
+                        transaction: "single-process-file-lock",
+                        backupFiles: listBackedUpFiles(backup.files),
+                    },
+                },
+            };
+        }
+        catch (error) {
+            try {
+                // Roll back the managed files to their pre-mutation state on any failure.
+                (0, backup_repo_1.restoreManifest)(backup);
+            }
+            catch (rollbackError) {
+                throw (0, errors_1.cliError)("ROLLBACK_FAILED", `${capitalize(args.operation)} failed and rollback was not successful.`, {
+                    cause: (0, errors_1.normalizeError)(error).message,
+                    rollbackReason: (0, errors_1.normalizeError)(rollbackError).message,
+                    backupPath: backup.backupDir,
+                });
+            }
+            const baseError = (0, errors_1.normalizeError)(error);
+            throw (0, errors_1.cliError)(baseError.code, baseError.message, {
+                ...(baseError.details ?? {}),
+                rollbackApplied: true,
+                backupPath: backup.backupDir,
+            });
+        }
+    });
+}
+/**
+ * Lists the files that existed before the mutation and were captured in the backup.
+ */
+function listBackedUpFiles(files) {
+    return files.filter((entry) => entry.existed).map((entry) => entry.relativePath);
+}
+/**
+ * Uppercases the first character for human-readable operation names.
+ */
+function capitalize(value) {
+    if (value.length === 0) {
+        return value;
+    }
+    return `${value[0].toUpperCase()}${value.slice(1)}`;
+}

package/dist/app/switch-provider.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.switchProvider = switchProvider;
+const errors_1 = require("../domain/errors");
+const config_repo_1 = require("../infra/config-repo");
+const codex_cli_1 = require("../infra/codex-cli");
+const providers_repo_1 = require("../infra/providers-repo");
+const run_mutation_1 = require("./run-mutation");
+/**
+ * Switches the active Codex profile and optionally refreshes the CLI login session.
+ */
+function switchProvider(args) {
+    const providers = (0, providers_repo_1.readProvidersFile)(args.providersPath);
+    const provider = providers.providers[args.providerName];
+    if (!provider) {
+        throw (0, errors_1.cliError)("PROVIDER_NOT_FOUND", `Provider "${args.providerName}" was not found.`, {
+            availableProviders: Object.keys(providers.providers).sort(),
+        });
+    }
+    const configContent = (0, config_repo_1.ensureProfileExists)(args.configPath, provider.profile, args.providerName);
+    return (0, run_mutation_1.runMutation)({
+        codexDir: args.codexDir,
+        backupsDir: args.backupsDir,
+        latestBackupPath: args.latestBackupPath,
+        operation: "switch",
+        files: [
+            { absolutePath: args.configPath, relativePath: "config.toml" },
+            { absolutePath: args.authPath, relativePath: "auth.json" },
+        ],
+        mutate: () => {
+            // Update the runtime profile first so any subsequent login is associated with the new target.
+            (0, config_repo_1.updateTopLevelProfile)(args.configPath, configContent, provider.profile);
+            if (!args.noLogin) {
+                (0, codex_cli_1.runCodexLogin)(provider.apiKey, args.codexDir);
+            }
+            return {
+                provider: args.providerName,
+                profile: provider.profile,
+                loginPerformed: !args.noLogin,
+            };
+        },
+    });
+}

package/dist/app/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli/add-interactive.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectAddInput = collectAddInput;
+exports.createNonInteractiveAddError = createNonInteractiveAddError;
+const config_repo_1 = require("../infra/config-repo");
+const errors_1 = require("../domain/errors");
+/**
+ * Collects add command inputs interactively when required values are missing.
+ */
+async function collectAddInput(runtime, defaults, providerExists, configPath) {
+    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 promptProfile(runtime, configPath);
+    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
+        : parseTags(await runtime.inputText("Tags (optional, comma-separated)"));
+    return {
+        providerName,
+        profile,
+        apiKey,
+        baseUrl,
+        note,
+        tags,
+    };
+}
+/**
+ * Throws a consistent error when interactive add is unavailable.
+ */
+function createNonInteractiveAddError() {
+    return (0, errors_1.cliError)("INVALID_IMPORT_FILE", "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 promptProfile(runtime, configPath) {
+    const profileChoices = loadProfileChoices(configPath);
+    if (profileChoices.length > 0) {
+        return runtime.selectOne("Profile", profileChoices);
+    }
+    return promptRequiredValue(runtime, "Profile");
+}
+function loadProfileChoices(configPath) {
+    try {
+        return Array.from((0, config_repo_1.listConfigProfiles)(configPath))
+            .sort()
+            .map((profileName) => ({
+            value: profileName,
+            label: profileName,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+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;
+}
+function parseTags(value) {
+    return value
+        .split(",")
+        .map((tag) => tag.trim())
+        .filter((tag) => tag.length > 0);
+}