@minniexcode/codex-switch 0.0.5 → 0.0.6

package/dist/commands/registry.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMANDS = void 0;
+exports.getCommandDefinitions = getCommandDefinitions;
+exports.getKnownCommandIds = getKnownCommandIds;
+exports.findCommandDefinition = findCommandDefinition;
+exports.findCommandDefinitionByTokens = findCommandDefinitionByTokens;
+exports.resolveCommandFromArgv = resolveCommandFromArgv;
+exports.isKnownCommandName = isKnownCommandName;
+exports.isKnownHelpTopic = isKnownHelpTopic;
+exports.getPublicCommandNames = getPublicCommandNames;
+exports.getNestedCommandTokens = getNestedCommandTokens;
+const handlers_1 = require("./handlers");
+exports.COMMANDS = [
+    {
+        id: "config-show",
+        tokens: ["config", "show"],
+        handler: handlers_1.handleRegisteredCommand,
+        group: "read",
+        summary: "Show the structured config profile view.",
+        usage: ["codexs config show [profile] [--json] [--codex-dir <path>]"],
+        details: [
+            "Returns all recognizable config profiles by default, including unmanaged and orphaned references.",
+            "Passing [profile] narrows the response to one profile while preserving the same shape.",
+        ],
+        examples: ["codexs config show", "codexs config show packycode --json"],
+    },
+    {
+        id: "config-list-profiles",
+        tokens: ["config", "list-profiles"],
+        handler: handlers_1.handleRegisteredCommand,
+        group: "read",
+        summary: "List recognizable config profiles with managed-state hints.",
+        usage: ["codexs config list-profiles [--json] [--codex-dir <path>]"],
+        details: [
+            "Lists managed, unmanaged, and orphaned config profiles in one stable view.",
+            "Use config show for richer single-profile details.",
+        ],
+        examples: ["codexs config list-profiles", "codexs config list-profiles --json"],
+    },
+    {
+        id: "setup",
+        tokens: ["setup"],
+        handler: handlers_1.handleRegisteredCommand,
+        group: "write",
+        summary: "Initialize providers.json from an existing Codex directory.",
+        usage: ["codexs setup [--json] [--codex-dir <path>] [--merge|--overwrite]"],
+        details: [
+            "Reads config.toml profiles, collects complete provider records, then writes providers.json under managed backup flow.",
+            "TTY mode can collect missing provider details and choose merge or overwrite when providers.json already exists.",
+            "In 0.0.6, setup adopt initialization requires a real TTY because profile selection and provider details are collected interactively.",
+            "Non-TTY and --json runs fail fast with a structured error instead of entering partial setup behavior.",
+        ],
+        examples: ["codexs setup", "codexs setup --overwrite --json --codex-dir ~/.codex"],
+    },
+    {
+        id: "list",
+        tokens: ["list"],
+        handler: handlers_1.handleRegisteredCommand,
+        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"],
+    },
+    {
+        id: "show",
+        tokens: ["show"],
+        handler: handlers_1.handleRegisteredCommand,
+        group: "read",
+        summary: "Show one provider record from providers.json.",
+        usage: ["codexs show <provider> [--json] [--codex-dir <path>]"],
+        details: [
+            "Human-readable output masks apiKey by default.",
+            "TTY mode can select a missing provider interactively before showing its record.",
+            "JSON mode returns the full provider payload for local automation.",
+        ],
+        examples: ["codexs show packycode", "codexs show packycode --json"],
+    },
+    {
+        id: "current",
+        tokens: ["current"],
+        handler: handlers_1.handleRegisteredCommand,
+        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"],
+    },
+    {
+        id: "status",
+        tokens: ["status"],
+        handler: handlers_1.handleRegisteredCommand,
+        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.",
+            "Surfaces config consistency signals without mutating any files.",
+            "Use doctor for deeper diagnostics.",
+        ],
+        examples: ["codexs status", "codexs status --json --codex-dir ./.tmp-codex"],
+    },
+    {
+        id: "edit",
+        tokens: ["edit"],
+        handler: handlers_1.handleRegisteredCommand,
+        group: "write",
+        summary: "Update fields on a single provider record.",
+        usage: [
+            "codexs edit <provider> [--profile <name>] [--api-key <key>] [--base-url <url>] [--note <text>] [--tag <tag> ...] [--json] [--codex-dir <path>]",
+            "codexs edit <provider> --profile <name> --create-profile --model <name> --base-url <url>",
+        ],
+        details: [
+            "Passed flags replace only the selected fields and keep the rest unchanged.",
+            "TTY mode can first select a provider, then prompt for fields when no editable options were provided.",
+            "Interactive tags use preset multi-select plus optional custom comma-separated input.",
+            "When rebinding to a missing profile, --create-profile requires both --model and --base-url.",
+            "Backs up providers.json and config.toml before writing.",
+        ],
+        examples: ["codexs edit packycode --note primary", "codexs edit packycode --tag daily --tag paid --json"],
+    },
+    {
+        id: "add",
+        tokens: ["add"],
+        handler: handlers_1.handleRegisteredCommand,
+        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 <provider> --profile <name> --api-key <key> --create-profile --model <name> --base-url <url>",
+            "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.",
+            "Interactive add collects provider name, profile, and apiKey progressively as plain text inputs.",
+            "Confirm API key when prompted interactively because the hidden prompt asks twice before writing.",
+            "Interactive tags use preset multi-select plus optional custom comma-separated input.",
+            "Automation and non-TTY environments must pass all required values explicitly.",
+            "Creating a missing profile section requires --create-profile together with --model and --base-url.",
+        ],
+        examples: ["codexs add packycode --profile packycode --api-key sk-xxx", "codexs add packycode --profile packycode", "codexs add"],
+    },
+    {
+        id: "switch",
+        tokens: ["switch"],
+        handler: handlers_1.handleRegisteredCommand,
+        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"],
+    },
+    {
+        id: "remove",
+        tokens: ["remove"],
+        handler: handlers_1.handleRegisteredCommand,
+        group: "write",
+        summary: "Remove a provider from providers.json.",
+        usage: ["codexs remove <provider> [--force] [--switch-to <profile>] [--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.",
+            "When removing the last provider linked to the active profile, pass --switch-to first.",
+            "Backs up providers.json and config.toml before removing the record.",
+        ],
+        examples: ["codexs remove freemodel", "codexs remove freemodel --force --json"],
+    },
+    {
+        id: "import",
+        tokens: ["import"],
+        handler: handlers_1.handleRegisteredCommand,
+        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 or merging into 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 --merge --json"],
+    },
+    {
+        id: "export",
+        tokens: ["export"],
+        handler: handlers_1.handleRegisteredCommand,
+        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"],
+    },
+    {
+        id: "backups-list",
+        tokens: ["backups", "list"],
+        handler: handlers_1.handleRegisteredCommand,
+        group: "recovery",
+        summary: "List historical backup entries.",
+        usage: ["codexs backups list [--json] [--codex-dir <path>]"],
+        details: [
+            "Enumerates backups/ manifests and returns them newest first.",
+            "Corrupt backup manifests are skipped with warnings instead of failing the whole command.",
+        ],
+        examples: ["codexs backups list", "codexs backups list --json"],
+    },
+    {
+        id: "doctor",
+        tokens: ["doctor"],
+        handler: handlers_1.handleRegisteredCommand,
+        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"],
+    },
+    {
+        id: "rollback",
+        tokens: ["rollback"],
+        handler: handlers_1.handleRegisteredCommand,
+        group: "recovery",
+        summary: "Restore the latest managed backup or a specific backup id.",
+        usage: ["codexs rollback [<backup-id>] [--json] [--codex-dir <path>]"],
+        details: [
+            "TTY mode previews the target 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 20260511-221457-switch --json"],
+    },
+];
+const COMMAND_NAME_SET = new Set(exports.COMMANDS.flatMap((command) => [command.id, command.tokens.join(" ")]));
+const HELP_TOPIC_SET = new Set([
+    ...exports.COMMANDS.map((command) => command.tokens.join(" ")),
+    ...new Set(exports.COMMANDS.filter((command) => command.tokens.length > 1).map((command) => command.tokens[0])),
+]);
+function getCommandDefinitions() {
+    return exports.COMMANDS.slice();
+}
+function getKnownCommandIds() {
+    return exports.COMMANDS.map((command) => command.id);
+}
+function findCommandDefinition(commandId) {
+    if (commandId === "help" || commandId === "version") {
+        return null;
+    }
+    return exports.COMMANDS.find((command) => command.id === commandId) ?? null;
+}
+function findCommandDefinitionByTokens(tokens) {
+    return exports.COMMANDS.find((command) => command.tokens.join(" ") === tokens.join(" ")) ?? null;
+}
+function resolveCommandFromArgv(argv) {
+    for (const command of exports.COMMANDS
+        .slice()
+        .sort((left, right) => right.tokens.length - left.tokens.length)) {
+        const candidate = argv.slice(0, command.tokens.length);
+        if (candidate.length === command.tokens.length && candidate.join(" ") === command.tokens.join(" ")) {
+            return {
+                definition: command,
+                consumedTokens: command.tokens.length,
+            };
+        }
+    }
+    return {
+        definition: null,
+        consumedTokens: 0,
+    };
+}
+function isKnownCommandName(commandName) {
+    return COMMAND_NAME_SET.has(commandName);
+}
+function isKnownHelpTopic(topic) {
+    return HELP_TOPIC_SET.has(topic);
+}
+function getPublicCommandNames() {
+    return exports.COMMANDS.map((command) => command.tokens.join(" "));
+}
+function getNestedCommandTokens(rootToken) {
+    return exports.COMMANDS
+        .filter((command) => command.tokens.length > 1 && command.tokens[0] === rootToken)
+        .map((command) => command.tokens.join(" "));
+}

package/dist/commands/types.js

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

package/dist/domain/config.js

@@ -74,7 +74,9 @@ function parseStructuredConfig(configContent) {
     let activeProfile = null;
     let activeProfileRange = null;
     const profiles = [];
+    const modelProviders = [];
     let currentProfile = null;
+    let currentModelProvider = null;
     let inRoot = true;
     for (const line of lines) {
         const trimmed = line.content.trim();
@@ -83,6 +85,10 @@ function parseStructuredConfig(configContent) {
             if (currentProfile) {
                 currentProfile.sectionEnd = line.start;
             }
+            if (currentModelProvider) {
+                currentModelProvider.sectionEnd = line.start;
+                currentModelProvider = null;
+            }
             currentProfile = {
                 name: headerMatch[1],
                 headerStart: line.start,
@@ -90,19 +96,43 @@ function parseStructuredConfig(configContent) {
                 sectionEnd: configContent.length,
                 managedFieldInsertIndex: configContent.length,
                 modelValueRange: null,
-                baseUrlValueRange: null,
+                modelProviderValueRange: null,
                 model: null,
-                baseUrl: null,
+                modelProvider: null,
             };
             profiles.push(currentProfile);
             inRoot = false;
             continue;
         }
+        const modelProviderHeaderMatch = trimmed.match(/^\[model_providers\.([^\]]+)\]$/);
+        if (modelProviderHeaderMatch) {
+            if (currentProfile) {
+                currentProfile.sectionEnd = line.start;
+                currentProfile = null;
+            }
+            if (currentModelProvider) {
+                currentModelProvider.sectionEnd = line.start;
+            }
+            currentModelProvider = {
+                name: modelProviderHeaderMatch[1],
+                sectionStart: line.start,
+                sectionEnd: configContent.length,
+                baseUrlValueRange: null,
+                baseUrl: null,
+            };
+            modelProviders.push(currentModelProvider);
+            inRoot = false;
+            continue;
+        }
         if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
             if (currentProfile) {
                 currentProfile.sectionEnd = line.start;
                 currentProfile = null;
             }
+            if (currentModelProvider) {
+                currentModelProvider.sectionEnd = line.start;
+                currentModelProvider = null;
+            }
             inRoot = false;
             continue;
         }
@@ -125,10 +155,20 @@ function parseStructuredConfig(configContent) {
                     end: line.start + modelMatch.valueEnd,
                 };
             }
+            const modelProviderMatch = matchKeyValueLine(line.content, "model_provider");
+            if (modelProviderMatch) {
+                currentProfile.modelProvider = modelProviderMatch.value;
+                currentProfile.modelProviderValueRange = {
+                    start: line.start + modelProviderMatch.valueStart,
+                    end: line.start + modelProviderMatch.valueEnd,
+                };
+            }
+        }
+        if (currentModelProvider) {
             const baseUrlMatch = matchKeyValueLine(line.content, "base_url");
             if (baseUrlMatch) {
-                currentProfile.baseUrl = baseUrlMatch.value;
-                currentProfile.baseUrlValueRange = {
+                currentModelProvider.baseUrl = baseUrlMatch.value;
+                currentModelProvider.baseUrlValueRange = {
                     start: line.start + baseUrlMatch.valueStart,
                     end: line.start + baseUrlMatch.valueEnd,
                 };
@@ -144,6 +184,7 @@ function parseStructuredConfig(configContent) {
             ...profile,
             managedFieldInsertIndex: findManagedFieldInsertIndex(configContent, profile.sectionStart, profile.sectionEnd),
         })),
+        modelProviders,
     };
 }
 /**
@@ -151,10 +192,12 @@ function parseStructuredConfig(configContent) {
  */
 function buildManagedProfileViews(document, providers) {
     const linkMap = buildProfileLinkMap(providers);
+    const modelProviderMap = new Map(document.modelProviders.map((provider) => [provider.name, provider]));
     const views = [];
     const seen = new Set();
     for (const section of document.profiles) {
         const linkInfo = linkMap.get(section.name) ?? { linkedProviders: [], managed: false };
+        const modelProviderSection = section.modelProvider ? modelProviderMap.get(section.modelProvider) ?? null : null;
         seen.add(section.name);
         views.push({
             name: section.name,
@@ -162,8 +205,9 @@ function buildManagedProfileViews(document, providers) {
             isActive: document.activeProfile === section.name,
             linkedProviders: [...linkInfo.linkedProviders].sort(),
             model: section.model,
-            baseUrl: section.baseUrl,
-            managedFields: collectManagedFields(section.model, section.baseUrl),
+            modelProvider: section.modelProvider,
+            baseUrl: modelProviderSection?.baseUrl ?? null,
+            managedFields: collectManagedFields(section.model, section.modelProvider),
             source: linkInfo.managed ? "managed" : "unmanaged",
         });
     }
@@ -177,6 +221,7 @@ function buildManagedProfileViews(document, providers) {
             isActive: document.activeProfile === profile,
             linkedProviders: [...linkInfo.linkedProviders].sort(),
             model: null,
+            modelProvider: null,
             baseUrl: null,
             managedFields: [],
             source: "orphaned-reference",
@@ -210,6 +255,38 @@ function collectConfigConsistencyIssues(document, providers) {
                 providers: [...view.linkedProviders],
             });
         }
+        if (view.source !== "orphaned-reference") {
+            if (!view.modelProvider) {
+                issues.push({
+                    code: "MODEL_PROVIDER_MISSING",
+                    profile: view.name,
+                });
+            }
+            else {
+                if (view.modelProvider !== view.name) {
+                    issues.push({
+                        code: "MODEL_PROVIDER_NAME_MISMATCH",
+                        profile: view.name,
+                        modelProvider: view.modelProvider,
+                    });
+                }
+                const modelProviderSection = document.modelProviders.find((entry) => entry.name === view.modelProvider);
+                if (!modelProviderSection) {
+                    issues.push({
+                        code: "MODEL_PROVIDER_SECTION_MISSING",
+                        profile: view.name,
+                        modelProvider: view.modelProvider,
+                    });
+                }
+                else if (!modelProviderSection.baseUrl) {
+                    issues.push({
+                        code: "MODEL_PROVIDER_BASE_URL_MISSING",
+                        profile: view.name,
+                        modelProvider: view.modelProvider,
+                    });
+                }
+            }
+        }
     }
     if (document.activeProfile) {
         const activeLinkInfo = buildProfileLinkMap(providers).get(document.activeProfile);
@@ -232,19 +309,19 @@ function collectConfigConsistencyIssues(document, providers) {
  */
 function validateManagedProfileCreation(profile, fields) {
     const model = fields.model?.trim() ?? "";
-    const baseUrl = fields.baseUrl?.trim() ?? "";
-    if (!model || !baseUrl) {
-        throw (0, errors_1.cliError)("MANAGED_PROFILE_FIELDS_MISSING", `Managed profile "${profile}" requires both model and base_url.`, {
+    const modelProvider = fields.modelProvider?.trim() ?? "";
+    if (!model || !modelProvider) {
+        throw (0, errors_1.cliError)("MANAGED_PROFILE_FIELDS_MISSING", `Managed profile "${profile}" requires both model and model_provider.`, {
             profile,
             missingFields: [
                 !model ? "model" : null,
-                !baseUrl ? "base_url" : null,
+                !modelProvider ? "model_provider" : null,
             ].filter((value) => Boolean(value)),
         });
     }
     return {
         model,
-        baseUrl,
+        modelProvider,
     };
 }
 /**
@@ -344,7 +421,7 @@ function planConfigMutation(document, args) {
                 index: document.rawText.length,
                 text: `${prefix}[profiles.${profileName}]${document.lineEnding}` +
                     `model = ${JSON.stringify(requiredFields.model)}${document.lineEnding}` +
-                    `base_url = ${JSON.stringify(requiredFields.baseUrl)}${document.lineEnding}`,
+                    `model_provider = ${JSON.stringify(requiredFields.modelProvider)}${document.lineEnding}`,
             });
             createdProfileSections.push(profileName);
             continue;
@@ -384,7 +461,7 @@ function applyPatchOperations(rawText, operations) {
 function planSectionFieldMutation(document, section, fields, operations) {
     let updated = false;
     const modelText = fields.model !== undefined ? JSON.stringify(fields.model) : null;
-    const baseUrlText = fields.baseUrl !== undefined ? JSON.stringify(fields.baseUrl) : null;
+    const modelProviderText = fields.modelProvider !== undefined ? JSON.stringify(fields.modelProvider) : null;
     const inserts = [];
     if (modelText !== null && section.modelValueRange) {
         if (section.model !== fields.model) {
@@ -401,19 +478,19 @@ function planSectionFieldMutation(document, section, fields, operations) {
         inserts.push(`model = ${modelText}${document.lineEnding}`);
         updated = true;
     }
-    if (baseUrlText !== null && section.baseUrlValueRange) {
-        if (section.baseUrl !== fields.baseUrl) {
+    if (modelProviderText !== null && section.modelProviderValueRange) {
+        if (section.modelProvider !== fields.modelProvider) {
             operations.push({
                 kind: "replace-range",
-                start: section.baseUrlValueRange.start,
-                end: section.baseUrlValueRange.end,
-                text: baseUrlText,
+                start: section.modelProviderValueRange.start,
+                end: section.modelProviderValueRange.end,
+                text: modelProviderText,
             });
             updated = true;
         }
     }
-    else if (baseUrlText !== null && !section.baseUrlValueRange) {
-        inserts.push(`base_url = ${baseUrlText}${document.lineEnding}`);
+    else if (modelProviderText !== null && !section.modelProviderValueRange) {
+        inserts.push(`model_provider = ${modelProviderText}${document.lineEnding}`);
         updated = true;
     }
     if (inserts.length > 0) {
@@ -483,13 +560,13 @@ function findManagedFieldInsertIndex(rawText, sectionStart, sectionEnd) {
     }
     return sectionStart + lines[lastMeaningfulIndex].end;
 }
-function collectManagedFields(model, baseUrl) {
+function collectManagedFields(model, modelProvider) {
     const fields = [];
     if (model !== null) {
         fields.push("model");
     }
-    if (baseUrl !== null) {
-        fields.push("base_url");
+    if (modelProvider !== null) {
+        fields.push("model_provider");
     }
     return fields;
 }