@minniexcode/codex-switch 0.0.1 → 0.0.3

package/dist/cli/prompt.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromptRuntime = createPromptRuntime;
+const inquirer_1 = __importDefault(require("inquirer"));
+const errors_1 = require("../domain/errors");
+/**
+ * Creates the default prompt runtime backed by inquirer on the current process TTY.
+ */
+function createPromptRuntime() {
+    return {
+        isInteractive: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
+        inputText: async (message, options) => {
+            return handlePromptCancellation(async () => {
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: "input",
+                        name: "value",
+                        message,
+                        default: options?.defaultValue ?? undefined,
+                    },
+                ]);
+                return String(answer.value ?? "");
+            });
+        },
+        inputSecret: async (message) => {
+            return handlePromptCancellation(async () => {
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: "password",
+                        name: "value",
+                        message,
+                        mask: "*",
+                    },
+                ]);
+                return String(answer.value ?? "");
+            });
+        },
+        selectOne: async (message, choices) => {
+            return handlePromptCancellation(async () => {
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: "select",
+                        name: "value",
+                        message,
+                        choices: choices.map((choice) => ({
+                            value: choice.value,
+                            name: choice.hint ? `${choice.label} (${choice.hint})` : choice.label,
+                        })),
+                    },
+                ]);
+                return answer.value;
+            });
+        },
+        confirmAction: async (message, options) => {
+            return handlePromptCancellation(async () => {
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: "confirm",
+                        name: "value",
+                        message,
+                        default: options?.defaultValue ?? false,
+                    },
+                ]);
+                return Boolean(answer.value);
+            });
+        },
+        writeLine: (message) => {
+            process.stdout.write(`${message}\n`);
+        },
+    };
+}
+async function handlePromptCancellation(run) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (isPromptCancellation(error)) {
+            throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "Interactive prompt was cancelled.");
+        }
+        throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "Interactive prompt failed.", {
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+function isPromptCancellation(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.name === "ExitPromptError" || error.message.includes("force closed");
+}

package/dist/cli.js

@@ -1,30 +1,219 @@
 #!/usr/bin/env node
 "use strict";
-const args = process.argv.slice(2);
-const version = "0.0.1";
-const helpText = `codex-switch
-
-Bootstrap release for the future Codex provider/profile switching CLI.
-
-Usage:
-  codexs
-  codexs --help
-  codexs --version
-
-Status:
-  This package currently reserves the npm scope and exposes the planned CLI entrypoint.
-  The full switching workflow is not implemented yet.
-
-Docs:
-  https://github.com/minniexcode/codex-switch
-`;
-if (args.includes("--version") || args.includes("-v")) {
-    console.log(version);
-    process.exit(0);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printHelp = printHelp;
+exports.printVersion = printVersion;
+exports.executeCommand = executeCommand;
+const add_provider_1 = require("./app/add-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_providers_1 = require("./app/list-providers");
+const remove_provider_1 = require("./app/remove-provider");
+const rollback_latest_1 = require("./app/rollback-latest");
+const run_doctor_1 = require("./app/run-doctor");
+const switch_provider_1 = require("./app/switch-provider");
+const errors_1 = require("./domain/errors");
+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 prompt_1 = require("./cli/prompt");
+const VERSION = "0.0.3";
+/**
+ * Prints the command help text to stdout.
+ */
+function printHelp(commandName) {
+    process.stdout.write(`${(0, help_1.buildHelpText)(commandName)}\n`);
 }
-if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
-    console.log(helpText);
-    process.exit(0);
+/**
+ * Prints the current CLI version to stdout.
+ */
+function printVersion() {
+    process.stdout.write(`${VERSION}\n`);
+}
+/**
+ * Parses arguments, dispatches the selected command, and renders the final output.
+ */
+function main() {
+    const parsed = (0, args_1.parseArgs)(process.argv.slice(2));
+    if (parsed.versionRequested) {
+        printVersion();
+        process.exit(0);
+    }
+    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}`, {
+                availableCommands: (0, help_1.buildHelpText)(parsed.helpTarget).split("\n").slice(2),
+            }));
+            return;
+        }
+        printHelp(parsed.helpTarget);
+        process.exit(0);
+    }
+    if (!parsed.command) {
+        printHelp();
+        process.exit(0);
+    }
+    const ctx = {
+        command: parsed.command,
+        options: parsed.globalOptions,
+    };
+    executeCommand(ctx, parsed)
+        .then((result) => {
+        (0, output_1.outputSuccess)(ctx, result);
+    })
+        .catch((error) => {
+        (0, output_1.outputFailure)(ctx, (0, errors_1.normalizeError)(error));
+    });
+}
+/**
+ * Dispatches a parsed CLI command into the application layer.
+ */
+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 "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": {
+            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.");
+            }
+            return (0, switch_provider_1.switchProvider)({
+                codexDir: paths.codexDir,
+                backupsDir: paths.backupsDir,
+                latestBackupPath: paths.latestBackupPath,
+                configPath: paths.configPath,
+                providersPath: paths.providersPath,
+                authPath: paths.authPath,
+                providerName,
+                noLogin: (0, args_1.hasFlag)(parsed.commandOptions, "--no-login"),
+            });
+        }
+        case "import": {
+            const sourceFile = parsed.positionals[0];
+            if (!sourceFile) {
+                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "Missing import file path.");
+            }
+            if ((0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                await (0, interactive_1.confirmImport)(runtime, sourceFile);
+            }
+            return (0, import_providers_1.importProviders)({
+                codexDir: paths.codexDir,
+                backupsDir: paths.backupsDir,
+                latestBackupPath: paths.latestBackupPath,
+                providersPath: paths.providersPath,
+                sourceFile,
+            });
+        }
+        case "export": {
+            const targetFile = parsed.positionals[0];
+            if (!targetFile) {
+                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "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.");
+                }
+                force = true;
+            }
+            return (0, export_providers_1.exportProviders)({
+                providersPath: paths.providersPath,
+                targetFile,
+                force,
+            });
+        }
+        case "add": {
+            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]), paths.configPath);
+                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 "remove": {
+            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 (!force && !(0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "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,
+                backupsDir: paths.backupsDir,
+                latestBackupPath: paths.latestBackupPath,
+                providersPath: paths.providersPath,
+                providerName,
+            });
+        }
+        case "doctor":
+            return (0, run_doctor_1.runDoctor)({
+                codexDir: paths.codexDir,
+                configPath: paths.configPath,
+                providersPath: paths.providersPath,
+            });
+        case "rollback":
+            if ((0, interactive_1.canPrompt)(runtime, ctx.options.json)) {
+                await (0, interactive_1.confirmRollback)(runtime, paths.latestBackupPath);
+            }
+            return (0, rollback_latest_1.rollbackLatest)(paths.latestBackupPath);
+        default:
+            throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", `Unknown command: ${ctx.command}`);
+    }
+}
+if (require.main === module) {
+    main();
 }
-console.error(`Command not implemented yet: ${args.join(" ")}\nRun "codexs --help" for the current bootstrap status.`);
-process.exit(1);

package/dist/domain/backup.js

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

package/dist/domain/config.js

@@ -0,0 +1,106 @@
+"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.parseTopLevelProfile = parseTopLevelProfile;
+exports.parseProfileNames = parseProfileNames;
+exports.replaceTopLevelProfile = replaceTopLevelProfile;
+const os = __importStar(require("node:os"));
+/**
+ * Reads the active top-level profile from config.toml content.
+ */
+function parseTopLevelProfile(configContent) {
+    let inRoot = true;
+    for (const line of configContent.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+            inRoot = false;
+            continue;
+        }
+        if (!inRoot || trimmed === "" || trimmed.startsWith("#")) {
+            continue;
+        }
+        const match = trimmed.match(/^profile\s*=\s*["']([^"']+)["']/);
+        if (match) {
+            return match[1];
+        }
+    }
+    return null;
+}
+/**
+ * Collects all named profile sections declared in config.toml content.
+ */
+function parseProfileNames(configContent) {
+    const result = new Set();
+    for (const line of configContent.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        const match = trimmed.match(/^\[profiles\.([^\]]+)\]$/);
+        if (match) {
+            result.add(match[1]);
+        }
+    }
+    return result;
+}
+/**
+ * Replaces or inserts the top-level profile assignment while preserving the rest of the file.
+ */
+function replaceTopLevelProfile(configContent, profile) {
+    const lines = configContent.split(/\r?\n/);
+    let inRoot = true;
+    let replaced = false;
+    const nextLines = lines.map((line) => {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+            // Only the root section may contain the active `profile = ...` switch.
+            inRoot = false;
+            return line;
+        }
+        if (!replaced && inRoot && /^profile\s*=/.test(trimmed)) {
+            replaced = true;
+            return `profile = "${profile}"`;
+        }
+        return line;
+    });
+    if (!replaced) {
+        // When no root-level profile exists yet, insert it before the first section header.
+        const insertAt = nextLines.findIndex((line) => line.trim().startsWith("["));
+        if (insertAt === -1) {
+            nextLines.push(`profile = "${profile}"`);
+        }
+        else {
+            nextLines.splice(insertAt, 0, `profile = "${profile}"`);
+        }
+    }
+    return nextLines.join(os.EOL);
+}

package/dist/domain/errors.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cliError = cliError;
+exports.normalizeError = normalizeError;
+/**
+ * Creates an Error instance enriched with a stable CLI error code and optional details.
+ */
+function cliError(code, message, details) {
+    const error = new Error(message);
+    error.code = code;
+    error.details = details;
+    return error;
+}
+/**
+ * Normalizes unknown thrown values into the shared CLI error shape.
+ */
+function normalizeError(error) {
+    if (error && typeof error === "object" && "code" in error && "message" in error) {
+        const candidate = error;
+        return {
+            code: candidate.code ?? "INVALID_IMPORT_FILE",
+            message: candidate.message ?? "Unknown error.",
+            details: candidate.details,
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            code: "INVALID_IMPORT_FILE",
+            message: error.message,
+        };
+    }
+    return {
+        code: "INVALID_IMPORT_FILE",
+        message: String(error),
+    };
+}

package/dist/domain/providers.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProvidersShape = validateProvidersShape;
+exports.cleanProviderRecord = cleanProviderRecord;
+exports.sortProviders = sortProviders;
+exports.findProviderByProfile = findProviderByProfile;
+/**
+ * Validates and normalizes unknown JSON into the providers.json domain model.
+ */
+function validateProvidersShape(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error("Root value must be an object.");
+    }
+    const providersValue = input.providers;
+    if (!providersValue || typeof providersValue !== "object" || Array.isArray(providersValue)) {
+        throw new Error('Missing or invalid "providers" object.');
+    }
+    const providers = {};
+    for (const [name, value] of Object.entries(providersValue)) {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            throw new Error(`Provider "${name}" must be an object.`);
+        }
+        const provider = value;
+        if (typeof provider.profile !== "string" || provider.profile.trim() === "") {
+            throw new Error(`Provider "${name}" is missing a valid profile.`);
+        }
+        if (typeof provider.apiKey !== "string" || provider.apiKey.trim() === "") {
+            throw new Error(`Provider "${name}" is missing a valid apiKey.`);
+        }
+        if (provider.baseUrl !== undefined && typeof provider.baseUrl !== "string") {
+            throw new Error(`Provider "${name}" has an invalid baseUrl.`);
+        }
+        if (provider.note !== undefined && typeof provider.note !== "string") {
+            throw new Error(`Provider "${name}" has an invalid note.`);
+        }
+        if (provider.tags !== undefined &&
+            (!Array.isArray(provider.tags) || provider.tags.some((tag) => typeof tag !== "string"))) {
+            throw new Error(`Provider "${name}" has invalid tags.`);
+        }
+        // Normalize provider fields during validation so the persisted format stays clean.
+        providers[name] = cleanProviderRecord({
+            profile: provider.profile,
+            apiKey: provider.apiKey,
+            baseUrl: provider.baseUrl,
+            note: provider.note,
+            tags: provider.tags,
+        });
+    }
+    return { providers };
+}
+/**
+ * Trims optional fields and removes empty values from a provider record.
+ */
+function cleanProviderRecord(record) {
+    const next = {
+        profile: record.profile.trim(),
+        apiKey: record.apiKey.trim(),
+    };
+    if (record.baseUrl && record.baseUrl.trim() !== "") {
+        next.baseUrl = record.baseUrl.trim();
+    }
+    if (record.note && record.note.trim() !== "") {
+        next.note = record.note.trim();
+    }
+    if (record.tags && record.tags.length > 0) {
+        next.tags = record.tags.map((tag) => tag.trim()).filter((tag) => tag.length > 0);
+    }
+    return next;
+}
+/**
+ * Returns a copy of the providers file with provider names sorted deterministically.
+ */
+function sortProviders(providers) {
+    const orderedProviders = Object.keys(providers.providers)
+        .sort()
+        .reduce((accumulator, key) => {
+        accumulator[key] = providers.providers[key];
+        return accumulator;
+    }, {});
+    return { providers: orderedProviders };
+}
+/**
+ * Finds the provider name associated with a given Codex profile.
+ */
+function findProviderByProfile(providers, profile) {
+    for (const [name, provider] of Object.entries(providers.providers)) {
+        if (provider.profile === profile) {
+            return name;
+        }
+    }
+    return null;
+}

package/dist/domain/runtime-state.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorageRoles = getStorageRoles;
+exports.inspectLiveStateDrift = inspectLiveStateDrift;
+/**
+ * Returns the stable storage contract used by the CLI.
+ */
+function getStorageRoles() {
+    return {
+        managementSSOT: "providers.json",
+        runtimeMirrors: ["config.toml", "auth.json"],
+        rollbackState: "backups/latest.json",
+    };
+}
+/**
+ * Compares the live active profile against managed providers to detect drift.
+ */
+function inspectLiveStateDrift(currentProfile, providers) {
+    if (currentProfile === null) {
+        return {
+            currentProfile,
+            mappedProvider: null,
+            profileMapped: false,
+            canBackfillActiveProvider: false,
+            reason: providers ? "profile-missing" : "config-missing",
+        };
+    }
+    if (!providers) {
+        return {
+            currentProfile,
+            mappedProvider: null,
+            profileMapped: false,
+            canBackfillActiveProvider: false,
+            reason: "providers-missing",
+        };
+    }
+    for (const [name, provider] of Object.entries(providers.providers)) {
+        // A direct profile match means the runtime state is still managed.
+        if (provider.profile === currentProfile) {
+            return {
+                currentProfile,
+                mappedProvider: name,
+                profileMapped: true,
+                canBackfillActiveProvider: false,
+                reason: "ok",
+            };
+        }
+    }
+    return {
+        currentProfile,
+        mappedProvider: null,
+        profileMapped: false,
+        canBackfillActiveProvider: true,
+        reason: "provider-unmapped",
+    };
+}