@minniexcode/codex-switch 0.0.1 → 0.0.2

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/args.js

@@ -0,0 +1,98 @@
+"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) {
+    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 = [];
+    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);
+    }
+    const command = remaining[0] ?? null;
+    const positionals = [];
+    const commandOptions = new Map();
+    for (let index = 1; index < remaining.length; index += 1) {
+        const value = remaining[index];
+        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,
+    };
+}
+/**
+ * Creates a parsed result for built-in synthetic commands such as help/version.
+ */
+function defaultParsed(command) {
+    return {
+        command,
+        positionals: [],
+        globalOptions: {
+            json: false,
+            codexDir: (0, codex_paths_1.resolveCodexDir)(),
+        },
+        commandOptions: new Map(),
+    };
+}
+/**
+ * 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/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`);
+}

package/dist/cli.js

@@ -1,30 +1,190 @@
 #!/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.
+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 codex_paths_1 = require("./infra/codex-paths");
+const args_1 = require("./cli/args");
+const output_1 = require("./cli/output");
+const VERSION = "0.0.2";
+const HELP_TEXT = `codex-switch
 
 Usage:
-  codexs
-  codexs --help
-  codexs --version
+  codexs <command> [options]
 
-Status:
-  This package currently reserves the npm scope and exposes the planned CLI entrypoint.
-  The full switching workflow is not implemented yet.
+Commands:
+  codexs list
+  codexs current
+  codexs switch <provider> [--no-login]
+  codexs status
+  codexs import <file>
+  codexs export <file> [--force]
+  codexs add <provider> --profile <name> --api-key <key> [--base-url <url>] [--note <text>] [--tag <tag> ...]
+  codexs remove <provider> --force
+  codexs doctor
+  codexs rollback
 
-Docs:
-  https://github.com/minniexcode/codex-switch
-`;
-if (args.includes("--version") || args.includes("-v")) {
-    console.log(version);
-    process.exit(0);
+Global options:
+  --json
+  --codex-dir <path>
+  --help
+  --version`;
+/**
+ * Prints the command help text to stdout.
+ */
+function printHelp() {
+    process.stdout.write(`${HELP_TEXT}\n`);
+}
+/**
+ * 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.command) {
+        printHelp();
+        process.exit(0);
+    }
+    if (parsed.command === "help") {
+        printHelp();
+        process.exit(0);
+    }
+    if (parsed.command === "version") {
+        printVersion();
+        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) {
+    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": {
+            const providerName = parsed.positionals[0];
+            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.");
+            }
+            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.");
+            }
+            return (0, export_providers_1.exportProviders)({
+                providersPath: paths.providersPath,
+                targetFile,
+                force: (0, args_1.hasFlag)(parsed.commandOptions, "--force"),
+            });
+        }
+        case "add": {
+            const providerName = parsed.positionals[0];
+            if (!providerName) {
+                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "Missing provider name for add command.");
+            }
+            const profile = (0, args_1.getSingleOption)(parsed.commandOptions, "--profile");
+            const apiKey = (0, args_1.getSingleOption)(parsed.commandOptions, "--api-key");
+            if (!profile || !apiKey) {
+                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "add requires --profile and --api-key.");
+            }
+            return (0, add_provider_1.addProvider)({
+                codexDir: paths.codexDir,
+                backupsDir: paths.backupsDir,
+                latestBackupPath: paths.latestBackupPath,
+                providersPath: paths.providersPath,
+                providerName,
+                profile,
+                apiKey,
+                baseUrl: (0, args_1.getSingleOption)(parsed.commandOptions, "--base-url", false),
+                note: (0, args_1.getSingleOption)(parsed.commandOptions, "--note", false),
+                tags: parsed.commandOptions.get("--tag") ?? [],
+            });
+        }
+        case "remove": {
+            const providerName = parsed.positionals[0];
+            if (!providerName) {
+                throw (0, errors_1.cliError)("PROVIDER_NOT_FOUND", "Missing provider name for remove command.");
+            }
+            if (!(0, args_1.hasFlag)(parsed.commandOptions, "--force")) {
+                throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", "remove requires --force.");
+            }
+            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":
+            return (0, rollback_latest_1.rollbackLatest)(paths.latestBackupPath);
+        default:
+            throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", `Unknown command: ${ctx.command}`);
+    }
 }
-if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
-    console.log(helpText);
-    process.exit(0);
+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),
+    };
+}