@minniexcode/codex-switch 0.0.6 → 0.0.7

package/dist/domain/config.js

@@ -41,6 +41,7 @@ exports.parseStructuredConfig = parseStructuredConfig;
 exports.buildManagedProfileViews = buildManagedProfileViews;
 exports.collectConfigConsistencyIssues = collectConfigConsistencyIssues;
 exports.validateManagedProfileCreation = validateManagedProfileCreation;
+exports.buildManagedProfileEnvKey = buildManagedProfileEnvKey;
 exports.planProfileLifecycleOutcome = planProfileLifecycleOutcome;
 exports.planConfigMutation = planConfigMutation;
 exports.applyPatchOperations = applyPatchOperations;
@@ -119,6 +120,8 @@ function parseStructuredConfig(configContent) {
                 sectionEnd: configContent.length,
                 baseUrlValueRange: null,
                 baseUrl: null,
+                envKeyValueRange: null,
+                envKey: null,
             };
             modelProviders.push(currentModelProvider);
             inRoot = false;
@@ -173,6 +176,14 @@ function parseStructuredConfig(configContent) {
                     end: line.start + baseUrlMatch.valueEnd,
                 };
             }
+            const envKeyMatch = matchKeyValueLine(line.content, "env_key");
+            if (envKeyMatch) {
+                currentModelProvider.envKey = envKeyMatch.value;
+                currentModelProvider.envKeyValueRange = {
+                    start: line.start + envKeyMatch.valueStart,
+                    end: line.start + envKeyMatch.valueEnd,
+                };
+            }
         }
     }
     return {
@@ -207,6 +218,7 @@ function buildManagedProfileViews(document, providers) {
             model: section.model,
             modelProvider: section.modelProvider,
             baseUrl: modelProviderSection?.baseUrl ?? null,
+            envKey: modelProviderSection?.envKey ?? null,
             managedFields: collectManagedFields(section.model, section.modelProvider),
             source: linkInfo.managed ? "managed" : "unmanaged",
         });
@@ -223,6 +235,7 @@ function buildManagedProfileViews(document, providers) {
             model: null,
             modelProvider: null,
             baseUrl: null,
+            envKey: null,
             managedFields: [],
             source: "orphaned-reference",
         });
@@ -285,6 +298,28 @@ function collectConfigConsistencyIssues(document, providers) {
                         modelProvider: view.modelProvider,
                     });
                 }
+                else if (!modelProviderSection.envKey) {
+                    issues.push({
+                        code: "MODEL_PROVIDER_ENV_KEY_MISSING",
+                        profile: view.name,
+                        modelProvider: view.modelProvider,
+                    });
+                }
+            }
+            for (const providerName of view.linkedProviders) {
+                const provider = providers?.providers[providerName];
+                if (!provider) {
+                    continue;
+                }
+                if (provider.envKey !== view.envKey) {
+                    issues.push({
+                        code: "PROVIDER_ENV_KEY_MISMATCH",
+                        provider: providerName,
+                        profile: view.name,
+                        providerEnvKey: provider.envKey,
+                        runtimeEnvKey: view.envKey,
+                    });
+                }
             }
         }
     }
@@ -296,6 +331,13 @@ function collectConfigConsistencyIssues(document, providers) {
                 profile: document.activeProfile,
             });
         }
+        else if (activeLinkInfo.linkedProviders.length > 1) {
+            issues.push({
+                code: "ACTIVE_PROVIDER_UNRESOLVED",
+                profile: document.activeProfile,
+                providers: [...activeLinkInfo.linkedProviders],
+            });
+        }
     }
     return issues.sort((left, right) => {
         if (left.profile === right.profile) {
@@ -324,6 +366,17 @@ function validateManagedProfileCreation(profile, fields) {
         modelProvider,
     };
 }
+/**
+ * Normalizes a profile name into the default env_key used for generated runtime sections.
+ */
+function buildManagedProfileEnvKey(profile) {
+    const normalized = profile
+        .trim()
+        .replace(/[^A-Za-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toUpperCase();
+    return `${normalized || "PROVIDER"}_API_KEY`;
+}
 /**
  * Computes keep/delete/switch outcomes when a provider leaves or changes profiles.
  */
@@ -374,9 +427,12 @@ function planProfileLifecycleOutcome(args) {
 function planConfigMutation(document, args) {
     const operations = [];
     const createdProfileSections = [];
+    const createdModelProviderSections = [];
     const deletedProfileSections = [];
     const updatedProfiles = [];
+    const updatedModelProviders = [];
     const sectionMap = new Map(document.profiles.map((profile) => [profile.name, profile]));
+    const modelProviderSectionMap = new Map(document.modelProviders.map((entry) => [entry.name, entry]));
     if (args.setActiveProfile && args.setActiveProfile !== document.activeProfile) {
         const quoted = `"${args.setActiveProfile}"`;
         if (document.activeProfileRange) {
@@ -431,11 +487,46 @@ function planConfigMutation(document, args) {
             updatedProfiles.push(profileName);
         }
     }
+    for (const [profileName, fields] of Object.entries(args.upsertModelProviders ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+        const section = modelProviderSectionMap.get(profileName);
+        if (!section) {
+            const baseUrl = fields.baseUrl?.trim() ?? "";
+            const envKey = fields.envKey?.trim() ?? "";
+            if (!baseUrl || !envKey) {
+                throw (0, errors_1.cliError)("MANAGED_PROFILE_FIELDS_MISSING", `Model provider "${profileName}" requires both base_url and env_key.`, {
+                    profile: profileName,
+                    modelProvider: profileName,
+                    missingFields: [
+                        !baseUrl ? "base_url" : null,
+                        !envKey ? "env_key" : null,
+                    ].filter((value) => Boolean(value)),
+                });
+            }
+            const prefix = document.rawText.length > 0 && !document.rawText.endsWith(document.lineEnding)
+                ? document.lineEnding
+                : "";
+            operations.push({
+                kind: "insert-at",
+                index: document.rawText.length,
+                text: `${prefix}[model_providers.${profileName}]${document.lineEnding}` +
+                    `base_url = ${JSON.stringify(baseUrl)}${document.lineEnding}` +
+                    `env_key = ${JSON.stringify(envKey)}${document.lineEnding}`,
+            });
+            createdModelProviderSections.push(profileName);
+            continue;
+        }
+        const sectionUpdated = planModelProviderFieldMutation(section, fields, operations);
+        if (sectionUpdated) {
+            updatedModelProviders.push(profileName);
+        }
+    }
     return {
         operations,
         createdProfileSections,
+        createdModelProviderSections,
         deletedProfileSections,
         updatedProfiles,
+        updatedModelProviders,
         switchedActiveProfile: Boolean(args.setActiveProfile && args.setActiveProfile !== document.activeProfile),
     };
 }
@@ -502,6 +593,52 @@ function planSectionFieldMutation(document, section, fields, operations) {
     }
     return updated;
 }
+/**
+ * Plans base_url/env_key updates for one model_providers section.
+ */
+function planModelProviderFieldMutation(section, fields, operations) {
+    let updated = false;
+    const baseUrlText = fields.baseUrl !== undefined ? JSON.stringify(fields.baseUrl) : null;
+    const envKeyText = fields.envKey !== undefined ? JSON.stringify(fields.envKey) : null;
+    const inserts = [];
+    if (baseUrlText !== null && section.baseUrlValueRange) {
+        if (section.baseUrl !== fields.baseUrl) {
+            operations.push({
+                kind: "replace-range",
+                start: section.baseUrlValueRange.start,
+                end: section.baseUrlValueRange.end,
+                text: baseUrlText,
+            });
+            updated = true;
+        }
+    }
+    else if (baseUrlText !== null) {
+        inserts.push(`base_url = ${baseUrlText}`);
+    }
+    if (envKeyText !== null && section.envKeyValueRange) {
+        if (section.envKey !== fields.envKey) {
+            operations.push({
+                kind: "replace-range",
+                start: section.envKeyValueRange.start,
+                end: section.envKeyValueRange.end,
+                text: envKeyText,
+            });
+            updated = true;
+        }
+    }
+    else if (envKeyText !== null) {
+        inserts.push(`env_key = ${envKeyText}`);
+    }
+    if (inserts.length > 0) {
+        operations.push({
+            kind: "insert-at",
+            index: section.sectionEnd,
+            text: `${inserts.join("\n")}\n`,
+        });
+        updated = true;
+    }
+    return updated;
+}
 function splitWithOffsets(value) {
     if (value.length === 0) {
         return [];

package/dist/domain/providers.js

@@ -4,6 +4,7 @@ exports.validateProvidersShape = validateProvidersShape;
 exports.cleanProviderRecord = cleanProviderRecord;
 exports.sortProviders = sortProviders;
 exports.findProviderByProfile = findProviderByProfile;
+exports.findProvidersByProfile = findProvidersByProfile;
 exports.maskSecret = maskSecret;
 /**
  * Validates and normalizes unknown JSON into the providers.json domain model.
@@ -28,6 +29,9 @@ function validateProvidersShape(input) {
         if (typeof provider.apiKey !== "string" || provider.apiKey.trim() === "") {
             throw new Error(`Provider "${name}" is missing a valid apiKey.`);
         }
+        if (typeof provider.envKey !== "string" || provider.envKey.trim() === "") {
+            throw new Error(`Provider "${name}" is missing a valid envKey.`);
+        }
         if (provider.baseUrl !== undefined && typeof provider.baseUrl !== "string") {
             throw new Error(`Provider "${name}" has an invalid baseUrl.`);
         }
@@ -42,6 +46,7 @@ function validateProvidersShape(input) {
         providers[name] = cleanProviderRecord({
             profile: provider.profile,
             apiKey: provider.apiKey,
+            envKey: provider.envKey,
             baseUrl: provider.baseUrl,
             note: provider.note,
             tags: provider.tags,
@@ -56,6 +61,7 @@ function cleanProviderRecord(record) {
     const next = {
         profile: record.profile.trim(),
         apiKey: record.apiKey.trim(),
+        envKey: record.envKey.trim(),
     };
     if (record.baseUrl && record.baseUrl.trim() !== "") {
         next.baseUrl = record.baseUrl.trim();
@@ -84,12 +90,20 @@ function sortProviders(providers) {
  * Finds the provider name associated with a given Codex profile.
  */
 function findProviderByProfile(providers, profile) {
+    const matches = findProvidersByProfile(providers, profile);
+    return matches.length > 0 ? matches[0] : null;
+}
+/**
+ * Returns all provider names associated with a given Codex profile.
+ */
+function findProvidersByProfile(providers, profile) {
+    const matches = [];
     for (const [name, provider] of Object.entries(providers.providers)) {
         if (provider.profile === profile) {
-            return name;
+            matches.push(name);
         }
     }
-    return null;
+    return matches.sort();
 }
 /**
  * Masks a secret for human-readable output while preserving a short fingerprint.

package/dist/domain/setup.js

@@ -15,6 +15,7 @@ function buildSetupDrafts(profiles, detailsByProfile) {
             record: (0, providers_1.cleanProviderRecord)({
                 profile,
                 apiKey: detail.apiKey ?? "",
+                envKey: detail.envKey ?? "",
                 baseUrl: detail.baseUrl,
                 note: detail.note,
                 tags: detail.tags,

package/dist/infra/backup-repo.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.saveLatestManifest = exports.restoreManifest = exports.loadManifestById = exports.loadLatestManifest = exports.listBackups = exports.createBackup = void 0;
+/**
+ * Compatibility facade that re-exports backup repository helpers from storage.
+ */
 var backup_repo_1 = require("../storage/backup-repo");
 Object.defineProperty(exports, "createBackup", { enumerable: true, get: function () { return backup_repo_1.createBackup; } });
 Object.defineProperty(exports, "listBackups", { enumerable: true, get: function () { return backup_repo_1.listBackups; } });

package/dist/infra/codex-cli.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setCodexSpawnImplementation = exports.runCodexLogin = exports.resetCodexSpawnImplementation = exports.readCodexVersion = exports.checkCodexVersion = exports.checkCodexAvailable = void 0;
+/**
+ * Compatibility facade that re-exports codex CLI runtime helpers.
+ */
 var codex_cli_1 = require("../runtime/codex-cli");
 Object.defineProperty(exports, "checkCodexAvailable", { enumerable: true, get: function () { return codex_cli_1.checkCodexAvailable; } });
 Object.defineProperty(exports, "checkCodexVersion", { enumerable: true, get: function () { return codex_cli_1.checkCodexVersion; } });

package/dist/infra/codex-paths.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveCodexDir = exports.createCodexPaths = exports.CODEX_DIR_ENV_NAME = void 0;
+/**
+ * Compatibility facade that re-exports Codex path utilities from storage.
+ */
 var codex_paths_1 = require("../storage/codex-paths");
 Object.defineProperty(exports, "CODEX_DIR_ENV_NAME", { enumerable: true, get: function () { return codex_paths_1.CODEX_DIR_ENV_NAME; } });
 Object.defineProperty(exports, "createCodexPaths", { enumerable: true, get: function () { return codex_paths_1.createCodexPaths; } });

package/dist/infra/fs-utils.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeTextFileAtomic = exports.readRequiredFile = exports.printErrorDetails = exports.formatDetail = exports.ensureDir = void 0;
+/**
+ * Compatibility facade that re-exports shared filesystem helpers from storage.
+ */
 var fs_utils_1 = require("../storage/fs-utils");
 Object.defineProperty(exports, "ensureDir", { enumerable: true, get: function () { return fs_utils_1.ensureDir; } });
 Object.defineProperty(exports, "formatDetail", { enumerable: true, get: function () { return fs_utils_1.formatDetail; } });

package/dist/infra/lock-repo.js

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withCodexLock = void 0;
+/**
+ * Compatibility facade that re-exports Codex lock helpers from storage.
+ */
 var lock_repo_1 = require("../storage/lock-repo");
 Object.defineProperty(exports, "withCodexLock", { enumerable: true, get: function () { return lock_repo_1.withCodexLock; } });

package/dist/infra/providers-repo.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeProvidersFile = exports.readProvidersFileIfExists = exports.readProvidersFile = exports.readProviderRecord = exports.mergeProviders = void 0;
+/**
+ * Compatibility facade that re-exports provider repository helpers from storage.
+ */
 var providers_repo_1 = require("../storage/providers-repo");
 Object.defineProperty(exports, "mergeProviders", { enumerable: true, get: function () { return providers_repo_1.mergeProviders; } });
 Object.defineProperty(exports, "readProviderRecord", { enumerable: true, get: function () { return providers_repo_1.readProviderRecord; } });

package/dist/interaction/add-interactive.js

@@ -4,13 +4,12 @@ exports.COMMON_TAG_CHOICES = void 0;
 exports.collectAddInput = collectAddInput;
 exports.createNonInteractiveAddError = createNonInteractiveAddError;
 exports.promptTags = promptTags;
-exports.parseTags = parseTags;
 const errors_1 = require("../domain/errors");
 exports.COMMON_TAG_CHOICES = ["free", "paid", "daily", "backup"];
 /**
  * Collects add command inputs interactively when required values are missing.
  */
-async function collectAddInput(runtime, defaults, providerExists) {
+async function collectAddInput(runtime, defaults, providerExists, profileExists) {
     runtime.writeLine("Interactive add mode");
     runtime.writeLine("Provide the missing required fields. Press Enter to skip optional fields.");
     const providerName = defaults.providerName
@@ -20,13 +19,19 @@ async function collectAddInput(runtime, defaults, providerExists) {
     const apiKey = defaults.apiKey
         ? normalizeRequiredValue(defaults.apiKey)
         : await promptConfirmedSecret(runtime, "API key", "Confirm API key");
-    const baseUrl = defaults.baseUrl ?? normalizeOptionalValue(await runtime.inputText("Base URL (optional)"));
+    const createProfile = !profileExists(profile);
+    const model = createProfile ? await promptRequiredValue(runtime, `Model for new profile "${profile}"`) : null;
+    const baseUrl = createProfile
+        ? (defaults.baseUrl ? normalizeRequiredValue(defaults.baseUrl) : await promptRequiredValue(runtime, `Base URL for new profile "${profile}"`))
+        : defaults.baseUrl ?? normalizeOptionalValue(await runtime.inputText("Base URL (optional)"));
     const note = defaults.note ?? normalizeOptionalValue(await runtime.inputText("Note (optional)"));
     const tags = defaults.tags.length > 0 ? defaults.tags : await promptTags(runtime);
     return {
         providerName,
         profile,
         apiKey,
+        createProfile,
+        model,
         baseUrl,
         note,
         tags,
@@ -87,22 +92,8 @@ function normalizeOptionalValue(value) {
 }
 async function promptTags(runtime, defaults = []) {
     const defaultPresetTags = defaults.filter(isCommonTag);
-    const defaultCustomTags = defaults.filter((tag) => !isCommonTag(tag));
-    const presetTags = await runtime.selectMany("Select tags (optional)", exports.COMMON_TAG_CHOICES.map((tag) => ({ value: tag, label: tag })), { defaultValues: defaultPresetTags });
-    const customTags = parseTags(await runtime.inputText("Custom tags (optional, comma-separated)", {
-        defaultValue: defaultCustomTags.join(", "),
-    }));
-    return dedupeTags([...presetTags, ...customTags]);
-}
-function parseTags(value) {
-    return dedupeTags(value
-        .split(",")
-        .map((tag) => tag.trim())
-        .filter((tag) => tag.length > 0));
+    return runtime.selectMany("Select tags (optional)", exports.COMMON_TAG_CHOICES.map((tag) => ({ value: tag, label: tag })), { defaultValues: defaultPresetTags });
 }
 function isCommonTag(tag) {
     return exports.COMMON_TAG_CHOICES.includes(tag);
 }
-function dedupeTags(tags) {
-    return Array.from(new Set(tags));
-}

package/dist/interaction/interactive.js

@@ -44,6 +44,7 @@ exports.getRollbackSummaryById = getRollbackSummaryById;
 exports.confirmRollback = confirmRollback;
 exports.chooseSetupStrategy = chooseSetupStrategy;
 exports.chooseCodexDir = chooseCodexDir;
+exports.confirmCreateCodexDir = confirmCreateCodexDir;
 exports.chooseSetupProfiles = chooseSetupProfiles;
 exports.collectSetupProviderDetails = collectSetupProviderDetails;
 exports.collectEditInput = collectEditInput;
@@ -61,6 +62,9 @@ const add_interactive_1 = require("./add-interactive");
 function canPrompt(runtime, jsonMode) {
     return !jsonMode && runtime.isInteractive();
 }
+/**
+ * Prompts the user to choose one configured provider when a command omitted its target.
+ */
 async function promptForProviderSelection(runtime, providersPath, message) {
     const providers = (0, providers_repo_1.readProvidersFile)(providersPath);
     const choices = Object.entries(providers.providers)
@@ -75,6 +79,9 @@ async function promptForProviderSelection(runtime, providersPath, message) {
     }
     return runtime.selectOne(message, choices);
 }
+/**
+ * Confirms destructive provider removal and turns a declined prompt into a typed cancellation.
+ */
 async function confirmProviderRemoval(runtime, providerName) {
     const confirmed = await runtime.confirmAction(`Remove provider "${providerName}"?`, {
         defaultValue: false,
@@ -83,6 +90,9 @@ async function confirmProviderRemoval(runtime, providerName) {
         throw (0, errors_1.cliError)("PROMPT_CANCELLED", `Removal cancelled for provider "${providerName}".`);
     }
 }
+/**
+ * Confirms provider import semantics, including whether the file will merge or replace the registry.
+ */
 async function confirmImport(runtime, sourceFile, merge = false) {
     const confirmed = await runtime.confirmAction(merge
         ? `Import providers from ${path.resolve(sourceFile)} and merge into the current registry?`
@@ -91,22 +101,37 @@ async function confirmImport(runtime, sourceFile, merge = false) {
         throw (0, errors_1.cliError)("PROMPT_CANCELLED", "Import cancelled.");
     }
 }
+/**
+ * Confirms whether an existing export target may be overwritten.
+ */
 async function confirmExportOverwrite(runtime, targetFile) {
     return runtime.confirmAction(`Overwrite existing export target ${path.resolve(targetFile)}?`, {
         defaultValue: false,
     });
 }
+/**
+ * Resolves whether the export target already exists after normalizing to an absolute path.
+ */
 function exportTargetExists(targetFile) {
     return fs.existsSync(path.resolve(targetFile));
 }
+/**
+ * Builds a rollback preview for the latest managed backup.
+ */
 function getRollbackSummary(latestBackupPath) {
     const manifest = (0, backup_repo_1.loadLatestManifest)(latestBackupPath);
     return buildRollbackSummary(manifest);
 }
+/**
+ * Builds a rollback preview for one explicit backup id.
+ */
 function getRollbackSummaryById(backupsDir, backupId) {
     const manifest = (0, backup_repo_1.loadManifestById)(backupsDir, backupId);
     return buildRollbackSummary(manifest);
 }
+/**
+ * Converts a backup manifest into the human preview shown before rollback confirmation.
+ */
 function buildRollbackSummary(manifest) {
     const previewLines = [
         "Rollback preview",
@@ -119,6 +144,9 @@ function buildRollbackSummary(manifest) {
     ];
     return { manifest, previewLines };
 }
+/**
+ * Prints the rollback preview and requires explicit confirmation before restore proceeds.
+ */
 async function confirmRollback(runtime, latestBackupPath, backupsDir, backupId) {
     const { previewLines } = backupId && backupsDir
         ? getRollbackSummaryById(backupsDir, backupId)
@@ -133,13 +161,19 @@ async function confirmRollback(runtime, latestBackupPath, backupsDir, backupId)
         throw (0, errors_1.cliError)("PROMPT_CANCELLED", "Rollback cancelled.");
     }
 }
+/**
+ * Prompts for setup merge strategy when providers.json already exists.
+ */
 async function chooseSetupStrategy(runtime) {
-    return runtime.selectOne("providers.json already exists. Choose a setup strategy.", [
+    return runtime.selectOne("providers.json already exists. Choose a migrate strategy.", [
         { value: "merge", label: "merge", hint: "keep existing providers and override by imported names" },
         { value: "overwrite", label: "overwrite", hint: "replace the existing registry" },
-        { value: "cancel", label: "cancel", hint: "abort setup without writing" },
+        { value: "cancel", label: "cancel", hint: "abort migrate without writing" },
     ]);
 }
+/**
+ * Resolves the Codex directory from discovered candidates or a manually entered path.
+ */
 async function chooseCodexDir(runtime, candidates) {
     if (candidates.length === 0) {
         const manual = (await runtime.inputText("Codex directory path")).trim();
@@ -170,6 +204,17 @@ async function chooseCodexDir(runtime, candidates) {
     }
     return (0, codex_paths_1.resolveCodexDir)(manual);
 }
+/**
+ * Confirms whether a missing Codex directory should be created during init.
+ */
+async function confirmCreateCodexDir(runtime, codexDir) {
+    return runtime.confirmAction(`Create missing Codex directory ${codexDir}?`, {
+        defaultValue: false,
+    });
+}
+/**
+ * Lets setup adopt a subset of unmanaged config profiles into providers.json.
+ */
 async function chooseSetupProfiles(runtime, profiles) {
     if (profiles.length === 0) {
         return [];
@@ -177,29 +222,57 @@ async function chooseSetupProfiles(runtime, profiles) {
     return runtime.selectMany("Choose unmanaged config profiles to adopt into providers.json.", profiles.map((profile) => ({
         value: profile.name,
         label: profile.name,
-        hint: `${profile.model} | ${profile.baseUrl}`,
+        hint: `${profile.model} | ${profile.baseUrl} | ${profile.envKey}`,
     })));
 }
-async function collectSetupProviderDetails(runtime, profiles) {
+/**
+ * Collects provider metadata for each adopted config profile during setup.
+ */
+async function collectSetupProviderDetails(runtime, profiles, defaultsByProfile = {}) {
     const result = {};
     for (const profile of profiles) {
+        const defaults = defaultsByProfile[profile] ?? {};
         const providerName = (await runtime.inputText(`Provider name for profile "${profile}"`, {
-            defaultValue: profile,
+            defaultValue: defaults.providerName ?? profile,
+        })).trim();
+        if (defaults.envKey) {
+            runtime.writeLine(`Runtime env key for "${profile}": ${defaults.envKey}`);
+        }
+        const apiKey = await promptRequiredSecret(runtime, `API key for profile "${profile}"`, defaults.apiKey?.trim() || undefined);
+        const baseUrl = (await runtime.inputText(`Base URL note for profile "${profile}" (optional)`, {
+            defaultValue: defaults.baseUrl ?? "",
+        })).trim();
+        const note = (await runtime.inputText(`Note for profile "${profile}" (optional)`, {
+            defaultValue: defaults.note ?? "",
         })).trim();
-        const apiKey = (await runtime.inputSecret(`API key for profile "${profile}"`)).trim();
-        const baseUrl = (await runtime.inputText(`Base URL for profile "${profile}" (optional)`)).trim();
-        const note = (await runtime.inputText(`Note for profile "${profile}" (optional)`)).trim();
         const tags = await (0, add_interactive_1.promptTags)(runtime);
         result[profile] = {
-            providerName: providerName || profile,
+            providerName: providerName || defaults.providerName || profile,
             apiKey,
-            baseUrl: baseUrl || undefined,
-            note: note || undefined,
+            envKey: defaults.envKey,
+            baseUrl: baseUrl || defaults.baseUrl || undefined,
+            note: note || defaults.note || undefined,
+            // Empty selections are omitted so downstream setup validation can distinguish unset from explicit data.
             tags: tags.length > 0 ? tags : undefined,
         };
     }
     return result;
 }
+/**
+ * Re-prompts until a required secret value is provided, optionally falling back to a non-empty default.
+ */
+async function promptRequiredSecret(runtime, label, defaultValue) {
+    while (true) {
+        const value = (await runtime.inputSecret(label)).trim() || defaultValue || "";
+        if (value.length > 0) {
+            return value;
+        }
+        runtime.writeLine(`${label} is required.`);
+    }
+}
+/**
+ * Collects editable provider fields, preserving current values when prompts are left blank.
+ */
 async function collectEditInput(runtime, current) {
     const profile = (await runtime.inputText("Profile", { defaultValue: current.profile })).trim();
     const apiKey = (await runtime.inputSecret("API key")).trim() || current.apiKey;

package/dist/runtime/codex-probe.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.codexRuntimeProbe = void 0;
 exports.probeCodexRuntime = probeCodexRuntime;
 const codex_cli_1 = require("./codex-cli");
+/**
+ * Default dependency probe implementation for the local codex CLI runtime.
+ */
 exports.codexRuntimeProbe = {
     probe(options) {
         if (options?.minVersion) {
@@ -11,6 +14,9 @@ exports.codexRuntimeProbe = {
         return probeCodexRuntime();
     },
 };
+/**
+ * Checks whether the codex CLI is installed and, optionally, satisfies a minimum version.
+ */
 function probeCodexRuntime(minVersion) {
     const availability = (0, codex_cli_1.checkCodexAvailable)();
     if (!availability.ok) {
@@ -31,6 +37,7 @@ function probeCodexRuntime(minVersion) {
         };
     }
     if (minVersion) {
+        // Reuse the dedicated semver check so doctor and setup report the same unsupported-version behavior.
         const versionCheck = (0, codex_cli_1.checkCodexVersion)(minVersion);
         if (!versionCheck.ok) {
             return {