@minniexcode/codex-switch 0.0.1 → 0.0.3

package/dist/cli/args.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.hasFlag = hasFlag;
+exports.getSingleOption = getSingleOption;
+const errors_1 = require("../domain/errors");
+const codex_paths_1 = require("../infra/codex-paths");
+/**
+ * Parses argv into command positionals, global flags, and command-scoped options.
+ */
+function parseArgs(argv) {
+    let json = false;
+    let codexDir = (0, codex_paths_1.resolveCodexDir)();
+    const remaining = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === "--json") {
+            json = true;
+            continue;
+        }
+        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.");
+            }
+            codexDir = (0, codex_paths_1.resolveCodexDir)(next);
+            index += 1;
+            continue;
+        }
+        remaining.push(value);
+    }
+    if (remaining[0] === "help") {
+        return {
+            command: null,
+            positionals: [],
+            globalOptions: {
+                json,
+                codexDir,
+            },
+            commandOptions: new Map(),
+            helpRequested: true,
+            helpTarget: remaining[1] ?? null,
+            versionRequested: false,
+        };
+    }
+    const versionRequested = remaining.includes("--version") || remaining.includes("-v");
+    if (versionRequested) {
+        return defaultParsed(null, {
+            json,
+            codexDir,
+            versionRequested: true,
+        });
+    }
+    const command = remaining[0] ?? null;
+    const positionals = [];
+    const commandOptions = new Map();
+    let helpRequested = false;
+    for (let index = 1; 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];
+            if (!next || next.startsWith("--")) {
+                // Boolean flags are stored as "true" so later access uses one uniform map shape.
+                commandOptions.set(optionName, ["true"]);
+                continue;
+            }
+            const existing = commandOptions.get(optionName) ?? [];
+            existing.push(next);
+            commandOptions.set(optionName, existing);
+            index += 1;
+            continue;
+        }
+        positionals.push(value);
+    }
+    return {
+        command,
+        positionals,
+        globalOptions: {
+            json,
+            codexDir,
+        },
+        commandOptions,
+        helpRequested,
+        helpTarget: helpRequested ? command : null,
+        versionRequested: false,
+    };
+}
+/**
+ * Creates a parsed result for built-in synthetic commands such as help/version.
+ */
+function defaultParsed(command, overrides) {
+    return {
+        command,
+        positionals: [],
+        globalOptions: {
+            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,
+    };
+}
+/**
+ * Checks whether a boolean-style option was supplied.
+ */
+function hasFlag(options, name) {
+    return options.has(name);
+}
+/**
+ * Returns the last supplied value for a single-valued command option.
+ */
+function getSingleOption(options, name, required = true) {
+    const values = options.get(name) ?? [];
+    if (values.length === 0) {
+        return required ? null : null;
+    }
+    return values[values.length - 1];
+}

package/dist/cli/help.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKnownCommandNames = getKnownCommandNames;
+exports.isKnownCommandName = isKnownCommandName;
+exports.buildHelpText = buildHelpText;
+const GROUP_TITLES = {
+    read: "Read Commands",
+    write: "Change Commands",
+    recovery: "Diagnostics And Recovery",
+};
+const COMMANDS = [
+    {
+        name: "list",
+        group: "read",
+        summary: "List configured providers from providers.json.",
+        usage: ["codexs list [--json] [--codex-dir <path>]"],
+        details: [
+            "Reads providers.json and prints provider-to-profile mappings.",
+            "Use --json for machine-readable automation output.",
+        ],
+        examples: ["codexs list", "codexs list --json"],
+    },
+    {
+        name: "current",
+        group: "read",
+        summary: "Show the active top-level profile from config.toml.",
+        usage: ["codexs current [--json] [--codex-dir <path>]"],
+        details: [
+            "Reads the currently active top-level profile.",
+            "Fails when config.toml is missing or has no top-level profile.",
+        ],
+        examples: ["codexs current", "codexs current --json"],
+    },
+    {
+        name: "status",
+        group: "read",
+        summary: "Show a quick status summary for the local Codex directory.",
+        usage: ["codexs status [--json] [--codex-dir <path>]"],
+        details: [
+            "Reports file presence, current profile, and whether the live profile is mapped.",
+            "Use doctor for deeper diagnostics.",
+        ],
+        examples: ["codexs status", "codexs status --json --codex-dir ./.tmp-codex"],
+    },
+    {
+        name: "add",
+        group: "write",
+        summary: "Add a provider with explicit flags or progressive TTY prompts.",
+        usage: [
+            "codexs add <provider> --profile <name> --api-key <key> [--base-url <url>] [--note <text>] [--tag <tag> ...]",
+            "codexs add [--profile <name>] [--api-key <key>] [--base-url <url>] [--note <text>] [--tag <tag> ...]",
+        ],
+        details: [
+            "Prompts only for missing required values when stdin/stdout are TTYs and --json is not set.",
+            "Profile selection prefers existing config.toml profiles, then falls back to free-text input.",
+            "Confirm API key when prompted interactively because the hidden prompt asks twice before writing.",
+            "Automation and non-TTY environments must pass all required values explicitly.",
+        ],
+        examples: [
+            "codexs add packycode --profile packycode --api-key sk-xxx",
+            "codexs add packycode --profile packycode",
+            "codexs add",
+        ],
+    },
+    {
+        name: "switch",
+        group: "write",
+        summary: "Switch to a provider and optionally refresh Codex login.",
+        usage: ["codexs switch <provider> [--no-login] [--json] [--codex-dir <path>]"],
+        details: [
+            "When <provider> is omitted in a TTY, an interactive provider selector is shown.",
+            "When <provider> is passed explicitly, switch proceeds directly without extra confirmation.",
+            "--no-login remains explicit and is never prompted interactively.",
+            "Backs up config.toml and auth.json, then rolls back on failure.",
+        ],
+        examples: ["codexs switch freemodel", "codexs switch --no-login", "codexs switch freemodel --no-login --json"],
+    },
+    {
+        name: "remove",
+        group: "write",
+        summary: "Remove a provider from providers.json.",
+        usage: ["codexs remove <provider> [--force] [--json] [--codex-dir <path>]"],
+        details: [
+            "TTY mode can select a missing provider interactively and always asks for deletion confirmation.",
+            "Non-TTY and --json automation still require both <provider> and --force.",
+            "The confirmation prompt includes the provider name and cancels without writing when declined.",
+            "Backs up providers.json before removing the record.",
+        ],
+        examples: ["codexs remove freemodel", "codexs remove freemodel --force --json"],
+    },
+    {
+        name: "import",
+        group: "write",
+        summary: "Replace providers.json with an external JSON file.",
+        usage: ["codexs import <file> [--json] [--codex-dir <path>]"],
+        details: [
+            "The file path is always explicit; there is no path wizard in this release.",
+            "TTY mode asks for confirmation before replacing the current providers registry.",
+            "Non-TTY and --json runs stay non-interactive and validate the file before writing.",
+        ],
+        examples: ["codexs import ./providers.json", "codexs import ./providers.json --json"],
+    },
+    {
+        name: "export",
+        group: "write",
+        summary: "Export the current providers.json to another file.",
+        usage: ["codexs export <file> [--force] [--json] [--codex-dir <path>]"],
+        details: [
+            "The file path is always explicit; there is no path wizard in this release.",
+            "TTY mode asks before overwriting an existing target when --force is not supplied.",
+            "Non-TTY and --json automation require --force to overwrite an existing file.",
+        ],
+        examples: ["codexs export ./providers-backup.json", "codexs export ./providers-backup.json --force"],
+    },
+    {
+        name: "doctor",
+        group: "recovery",
+        summary: "Run configuration and environment diagnostics.",
+        usage: ["codexs doctor [--json] [--codex-dir <path>]"],
+        details: [
+            "Checks the expected config files, provider/profile consistency, and Codex CLI availability.",
+            "Returns structured issues so users and AI agents can act on them.",
+        ],
+        examples: ["codexs doctor", "codexs doctor --json"],
+    },
+    {
+        name: "rollback",
+        group: "recovery",
+        summary: "Restore the latest managed backup.",
+        usage: ["codexs rollback [--json] [--codex-dir <path>]"],
+        details: [
+            "TTY mode previews the latest backup path and affected files, then asks for confirmation.",
+            "Non-TTY and --json runs stay non-interactive and execute immediately.",
+            "Use after a failed or undesired managed mutation.",
+        ],
+        examples: ["codexs rollback", "codexs rollback --json"],
+    },
+];
+const COMMAND_NAME_SET = new Set(COMMANDS.map((command) => command.name));
+function getKnownCommandNames() {
+    return COMMANDS.map((command) => command.name);
+}
+function isKnownCommandName(commandName) {
+    return COMMAND_NAME_SET.has(commandName);
+}
+function buildHelpText(commandName) {
+    if (!commandName) {
+        return [
+            "codex-switch",
+            "",
+            "Manage and switch local Codex provider/profile configuration safely.",
+            "",
+            "Usage:",
+            "  codexs <command> [options]",
+            "  codexs help <command>",
+            "",
+            ...renderGroupedCommands(),
+            "",
+            "Global options:",
+            "  --json             Output the standard JSON envelope and disable all prompts.",
+            "  --codex-dir <path> Target a specific Codex directory instead of ~/.codex.",
+            "  --help             Show top-level or command-specific help.",
+            "  --version          Print the current CLI version.",
+            "",
+            "Interactive rules:",
+            "  Progressive prompts only run in a real TTY and never run under --json.",
+            "  Human write commands may guide missing inputs or ask for dangerous-action confirmation.",
+            "  Automation should pass explicit arguments and prefer --json for stable parsing.",
+            "",
+            "Dangerous commands:",
+            "  remove deletes provider records.",
+            "  import replaces providers.json.",
+            "  export may overwrite a target file.",
+            "  rollback restores files from the latest backup.",
+            "",
+            "Examples:",
+            "  codexs list",
+            "  codexs switch",
+            "  codexs add packycode --profile packycode --api-key sk-xxx",
+            "  codexs remove freemodel",
+            "  codexs rollback",
+            "  codexs help add",
+        ].join("\n");
+    }
+    const command = COMMANDS.find((candidate) => candidate.name === commandName);
+    if (!command) {
+        return [
+            `Unknown help topic: ${commandName}`,
+            "",
+            "Available commands:",
+            ...getKnownCommandNames().map((name) => `  ${name}`),
+        ].join("\n");
+    }
+    return [
+        `codexs ${command.name}`,
+        "",
+        command.summary,
+        "",
+        "Usage:",
+        ...command.usage.map((usage) => `  ${usage}`),
+        "",
+        "Details:",
+        ...command.details.map((detail) => `  ${detail}`),
+        "",
+        "Examples:",
+        ...command.examples.map((example) => `  ${example}`),
+    ].join("\n");
+}
+function renderGroupedCommands() {
+    const lines = [];
+    for (const group of ["read", "write", "recovery"]) {
+        lines.push(`${GROUP_TITLES[group]}:`);
+        for (const command of COMMANDS.filter((candidate) => candidate.group === group)) {
+            lines.push(`  ${command.name.padEnd(8, " ")} ${command.summary}`);
+        }
+        lines.push("");
+    }
+    lines.pop();
+    return lines;
+}

package/dist/cli/interactive.js

@@ -0,0 +1,114 @@
+"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.canPrompt = canPrompt;
+exports.promptForProviderSelection = promptForProviderSelection;
+exports.confirmProviderRemoval = confirmProviderRemoval;
+exports.confirmImport = confirmImport;
+exports.confirmExportOverwrite = confirmExportOverwrite;
+exports.exportTargetExists = exportTargetExists;
+exports.getRollbackSummary = getRollbackSummary;
+exports.confirmRollback = confirmRollback;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const errors_1 = require("../domain/errors");
+const providers_repo_1 = require("../infra/providers-repo");
+const backup_repo_1 = require("../infra/backup-repo");
+/**
+ * Keeps CLI-side interactivity rules in one place so automation paths remain explicit.
+ */
+function canPrompt(runtime, jsonMode) {
+    return !jsonMode && runtime.isInteractive();
+}
+async function promptForProviderSelection(runtime, providersPath, message) {
+    const providers = (0, providers_repo_1.readProvidersFile)(providersPath);
+    const choices = Object.entries(providers.providers)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([providerName, provider]) => ({
+        value: providerName,
+        label: providerName,
+        hint: provider.profile,
+    }));
+    if (choices.length === 0) {
+        throw (0, errors_1.cliError)("PROVIDER_NOT_FOUND", "No providers are configured.");
+    }
+    return runtime.selectOne(message, choices);
+}
+async function confirmProviderRemoval(runtime, providerName) {
+    const confirmed = await runtime.confirmAction(`Remove provider "${providerName}"?`, {
+        defaultValue: false,
+    });
+    if (!confirmed) {
+        throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", `Removal cancelled for provider "${providerName}".`);
+    }
+}
+async function confirmImport(runtime, sourceFile) {
+    const confirmed = await runtime.confirmAction(`Import providers from ${path.resolve(sourceFile)} and replace the current registry?`, { defaultValue: false });
+    if (!confirmed) {
+        throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "Import cancelled.");
+    }
+}
+async function confirmExportOverwrite(runtime, targetFile) {
+    return runtime.confirmAction(`Overwrite existing export target ${path.resolve(targetFile)}?`, {
+        defaultValue: false,
+    });
+}
+function exportTargetExists(targetFile) {
+    return fs.existsSync(path.resolve(targetFile));
+}
+function getRollbackSummary(latestBackupPath) {
+    const manifest = (0, backup_repo_1.loadLatestManifest)(latestBackupPath);
+    const previewLines = [
+        "Rollback preview",
+        `Backup: ${manifest.backupDir}`,
+        ...manifest.files.map((file) => {
+            const suffix = file.existed ? "restore" : "remove";
+            return `- ${file.relativePath} (${suffix})`;
+        }),
+    ];
+    return { manifest, previewLines };
+}
+async function confirmRollback(runtime, latestBackupPath) {
+    const { previewLines } = getRollbackSummary(latestBackupPath);
+    for (const line of previewLines) {
+        runtime.writeLine(line);
+    }
+    const confirmed = await runtime.confirmAction("Restore files from the latest backup?", {
+        defaultValue: false,
+    });
+    if (!confirmed) {
+        throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "Rollback cancelled.");
+    }
+}

package/dist/cli/output.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderSuccess = renderSuccess;
+exports.renderFailure = renderFailure;
+exports.outputSuccess = outputSuccess;
+exports.outputFailure = outputFailure;
+const fs_utils_1 = require("../infra/fs-utils");
+/**
+ * Renders a successful command result for either JSON or human-readable output.
+ */
+function renderSuccess(ctx, result) {
+    const warnings = result.warnings ?? [];
+    if (ctx.options.json) {
+        const payload = {
+            ok: true,
+            command: ctx.command,
+            data: result.data,
+            warnings,
+            error: null,
+        };
+        return {
+            stdout: [JSON.stringify(payload, null, 2)],
+            stderr: [],
+            exitCode: 0,
+        };
+    }
+    return {
+        stdout: renderHumanSuccess(ctx.command, result.data, warnings),
+        stderr: [],
+        exitCode: 0,
+    };
+}
+/**
+ * Renders a failed command result for either JSON or human-readable output.
+ */
+function renderFailure(ctx, error) {
+    if (ctx.options.json) {
+        const payload = {
+            ok: false,
+            command: ctx.command,
+            data: null,
+            warnings: [],
+            error,
+        };
+        return {
+            stdout: [],
+            stderr: [JSON.stringify(payload, null, 2)],
+            exitCode: 1,
+        };
+    }
+    return {
+        stdout: [],
+        stderr: [`${error.code}: ${error.message}`, ...(0, fs_utils_1.printErrorDetails)(error)],
+        exitCode: 1,
+    };
+}
+/**
+ * Writes successful command output to stdout.
+ */
+function outputSuccess(ctx, result) {
+    const rendered = renderSuccess(ctx, result);
+    for (const line of rendered.stdout) {
+        printText(line);
+    }
+}
+/**
+ * Writes failure output to stderr and exits with the rendered status code.
+ */
+function outputFailure(ctx, error) {
+    const rendered = renderFailure(ctx, error);
+    for (const line of rendered.stderr) {
+        printText(line, true);
+    }
+    process.exit(rendered.exitCode);
+}
+/**
+ * Builds the plain-text success view for interactive terminal usage.
+ */
+function renderHumanSuccess(command, data, warnings) {
+    const lines = [];
+    switch (command) {
+        case "list": {
+            const providers = data?.providers ?? [];
+            if (providers.length === 0) {
+                lines.push("No providers configured.");
+            }
+            else {
+                for (const provider of providers) {
+                    const tags = Array.isArray(provider.tags) && provider.tags.length > 0
+                        ? ` tags=${provider.tags.join(",")}`
+                        : "";
+                    const note = provider.note ? ` note=${provider.note}` : "";
+                    lines.push(`${provider.name} -> ${provider.profile}${tags}${note}`);
+                }
+            }
+            break;
+        }
+        case "current":
+            lines.push(`Current profile: ${String(data?.profile ?? "")}`);
+            break;
+        case "status":
+            lines.push(`codexDir: ${String(data?.codexDir ?? "")}`);
+            lines.push(`configExists: ${String(data?.configExists ?? false)}`);
+            lines.push(`providersExists: ${String(data?.providersExists ?? false)}`);
+            lines.push(`currentProfile: ${String(data?.currentProfile ?? "")}`);
+            lines.push(`mappedProvider: ${String(data?.provider ?? "")}`);
+            break;
+        case "switch":
+            lines.push(`Switched to provider ${String(data?.provider ?? "")} using profile ${String(data?.profile ?? "")}.`);
+            lines.push(`Backup: ${String(data?.backupPath ?? "")}`);
+            lines.push(`Login performed: ${String(data?.loginPerformed ?? false)}`);
+            break;
+        case "import":
+            lines.push(`Imported providers from file. Backup: ${String(data?.backupPath ?? "")}`);
+            break;
+        case "export":
+            lines.push(`Exported providers to ${String(data?.exportedTo ?? "")}.`);
+            break;
+        case "add":
+            lines.push(`Added provider ${String(data?.provider ?? "")}. Backup: ${String(data?.backupPath ?? "")}`);
+            break;
+        case "remove":
+            lines.push(`Removed provider ${String(data?.provider ?? "")}. Backup: ${String(data?.backupPath ?? "")}`);
+            break;
+        case "doctor": {
+            const healthy = Boolean(data?.healthy);
+            lines.push(healthy ? "No issues found." : "Issues found:");
+            const issues = data?.issues ?? [];
+            for (const issue of issues) {
+                lines.push(`${issue.code}: ${issue.message}`);
+            }
+            break;
+        }
+        case "rollback":
+            lines.push(`Rollback restored files from ${String(data?.backupPath ?? "")}.`);
+            break;
+        default:
+            lines.push(JSON.stringify(data, null, 2));
+            break;
+    }
+    // Emit warnings after the primary payload so the main outcome remains easy to scan.
+    for (const warning of warnings) {
+        lines.push(`Warning: ${warning}`);
+    }
+    return lines;
+}
+/**
+ * Writes one rendered line to either stdout or stderr.
+ */
+function printText(message, toStderr = false) {
+    if (toStderr) {
+        process.stderr.write(`${message}\n`);
+        return;
+    }
+    process.stdout.write(`${message}\n`);
+}