@minniexcode/codex-switch 0.0.9 → 0.0.11

package/dist/runtime/copilot-cli.js

@@ -0,0 +1,142 @@
+"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.setCopilotCliSpawnImplementation = setCopilotCliSpawnImplementation;
+exports.resetCopilotCliSpawnImplementation = resetCopilotCliSpawnImplementation;
+exports.checkCopilotCliAvailable = checkCopilotCliAvailable;
+exports.runCopilotLogin = runCopilotLogin;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const copilot_installer_1 = require("./copilot-installer");
+let spawnImplementation = node_child_process_1.spawnSync;
+/**
+ * Overrides the spawn implementation for Copilot CLI tests.
+ */
+function setCopilotCliSpawnImplementation(spawnLike) {
+    spawnImplementation = spawnLike;
+}
+/**
+ * Restores the default spawn implementation after tests.
+ */
+function resetCopilotCliSpawnImplementation() {
+    spawnImplementation = node_child_process_1.spawnSync;
+}
+/**
+ * Checks whether the GitHub Copilot CLI is available either from the bundled runtime or on PATH.
+ */
+function checkCopilotCliAvailable(runtimesDir) {
+    const invocation = getCopilotInvocation(["--help"], runtimesDir);
+    const result = spawnImplementation(invocation.command, invocation.args, {
+        stdio: "pipe",
+        encoding: "utf8",
+        shell: invocation.shell,
+    });
+    if (result.error || result.status !== 0) {
+        return {
+            ok: false,
+            cause: result.error?.message ?? (result.stderr.trim() || "Unknown failure"),
+            source: invocation.source,
+            command: formatInvocation(invocation),
+        };
+    }
+    return {
+        ok: true,
+        source: invocation.source,
+        command: formatInvocation(invocation),
+    };
+}
+/**
+ * Launches the official `copilot login` flow in the current terminal.
+ */
+function runCopilotLogin(options) {
+    const args = ["login"];
+    if (options?.host) {
+        args.push("--hostname", options.host);
+    }
+    const invocation = getCopilotInvocation(args, options?.runtimesDir);
+    const result = spawnImplementation(invocation.command, invocation.args, {
+        stdio: "inherit",
+        shell: invocation.shell,
+    });
+    if (result.error || result.status !== 0) {
+        throw new Error(result.error?.message ??
+            `${formatInvocation(invocation)} exited with status ${String(result.status)}`);
+    }
+}
+/**
+ * Resolves a cross-platform invocation for the Copilot CLI.
+ */
+function getCopilotInvocation(args, runtimesDir) {
+    const bundledCommand = resolveBundledCopilotCommand(runtimesDir);
+    const executable = bundledCommand ?? "copilot";
+    if (process.platform === "win32") {
+        return {
+            command: executable,
+            args,
+            source: bundledCommand ? "bundled" : "path",
+            shell: true,
+        };
+    }
+    return {
+        command: executable,
+        args,
+        source: bundledCommand ? "bundled" : "path",
+        shell: false,
+    };
+}
+/**
+ * Resolves the bundled Copilot CLI shim installed alongside the optional runtime.
+ */
+function resolveBundledCopilotCommand(runtimesDir) {
+    const installDir = (0, copilot_installer_1.getCopilotRuntimeInstallDir)(runtimesDir);
+    const candidates = process.platform === "win32"
+        ? [path.join(installDir, "node_modules", ".bin", "copilot.cmd")]
+        : [path.join(installDir, "node_modules", ".bin", "copilot")];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * Renders the invocation into a short human-readable string for diagnostics.
+ */
+function formatInvocation(invocation) {
+    return invocation.command === "copilot"
+        ? ["copilot", ...invocation.args].join(" ")
+        : [invocation.command, ...invocation.args].join(" ");
+}

package/dist/runtime/copilot-installer.js

@@ -40,10 +40,10 @@ exports.getCopilotSdkPackageName = getCopilotSdkPackageName;
 exports.probeCopilotSdkInstall = probeCopilotSdkInstall;
 exports.installCopilotSdk = installCopilotSdk;
 const fs = __importStar(require("node:fs"));
-const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const errors_1 = require("../domain/errors");
+const codex_paths_1 = require("../storage/codex-paths");
 const COPILOT_SDK_PACKAGE = "@github/copilot-sdk";
 const COPILOT_SDK_VERSION = "latest";
 let spawnImplementation = node_child_process_1.spawnSync;
@@ -60,14 +60,15 @@ function resetCopilotInstallerSpawnImplementation() {
     spawnImplementation = node_child_process_1.spawnSync;
 }
 /**
- * Returns the user-level runtime directory used to lazily install the Copilot SDK.
+ * Returns the tool-home runtime directory used to lazily install the Copilot SDK.
  */
-function getCopilotRuntimeInstallDir() {
+function getCopilotRuntimeInstallDir(runtimesDir) {
     const override = process.env.CODEX_SWITCH_COPILOT_RUNTIME_DIR;
     if (override && override.trim() !== "") {
         return path.resolve(override);
     }
-    return path.join(os.homedir(), ".codex-switch", "runtimes", "copilot");
+    const baseRuntimesDir = runtimesDir ? path.resolve(runtimesDir) : path.join((0, codex_paths_1.resolveCodexSwitchHome)(), "runtimes");
+    return path.join(baseRuntimesDir, "copilot");
 }
 /**
  * Returns the package name used by the Copilot runtime installer.
@@ -78,8 +79,8 @@ function getCopilotSdkPackageName() {
 /**
  * Reports whether the optional Copilot SDK runtime is currently installed.
  */
-function probeCopilotSdkInstall() {
-    const installDir = getCopilotRuntimeInstallDir();
+function probeCopilotSdkInstall(runtimesDir) {
+    const installDir = getCopilotRuntimeInstallDir(runtimesDir);
     const packageJsonPath = path.join(installDir, "node_modules", "@github", "copilot-sdk", "package.json");
     if (!fs.existsSync(packageJsonPath)) {
         return {
@@ -100,26 +101,73 @@ function probeCopilotSdkInstall() {
 /**
  * Installs the optional Copilot SDK into the user-level runtime directory.
  */
-function installCopilotSdk() {
-    const installDir = getCopilotRuntimeInstallDir();
+function installCopilotSdk(runtimesDir) {
+    const installDir = getCopilotRuntimeInstallDir(runtimesDir);
     fs.mkdirSync(installDir, { recursive: true });
     const packageJsonPath = path.join(installDir, "package.json");
     if (!fs.existsSync(packageJsonPath)) {
         fs.writeFileSync(packageJsonPath, `${JSON.stringify({ name: "codex-switch-copilot-runtime", private: true, version: "0.0.0" }, null, 2)}\n`, "utf8");
     }
-    const command = process.platform === "win32" ? "npm.cmd" : "npm";
-    const result = spawnImplementation(command, ["install", "--no-save", `${COPILOT_SDK_PACKAGE}@${COPILOT_SDK_VERSION}`], {
+    const installCommand = resolveNpmInstallCommand();
+    const result = spawnImplementation(installCommand.command, installCommand.args, {
         cwd: installDir,
         stdio: "pipe",
         encoding: "utf8",
         shell: false,
     });
+    if (result.error) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_INSTALL_FAILED", "Failed to install the optional Copilot SDK runtime.", {
+            installDir,
+            packageName: COPILOT_SDK_PACKAGE,
+            cause: result.error.message,
+            errorCode: result.error.code ?? null,
+            command: installCommand.command,
+            args: installCommand.args,
+        });
+    }
     if (result.status !== 0) {
         throw (0, errors_1.cliError)("COPILOT_SDK_INSTALL_FAILED", "Failed to install the optional Copilot SDK runtime.", {
             installDir,
             packageName: COPILOT_SDK_PACKAGE,
             cause: result.stderr || result.stdout || `npm exited with status ${String(result.status)}`,
+            command: installCommand.command,
+            args: installCommand.args,
         });
     }
-    return probeCopilotSdkInstall();
+    return probeCopilotSdkInstall(runtimesDir);
+}
+/**
+ * Resolves a stable npm install invocation for the optional Copilot SDK runtime.
+ */
+function resolveNpmInstallCommand() {
+    const installArgs = ["install", "--no-save", `${COPILOT_SDK_PACKAGE}@${COPILOT_SDK_VERSION}`];
+    const npmCliPath = resolveNpmCliPath();
+    if (npmCliPath) {
+        return {
+            command: process.execPath,
+            args: [npmCliPath, ...installArgs],
+        };
+    }
+    return {
+        command: process.platform === "win32" ? "npm.cmd" : "npm",
+        args: installArgs,
+    };
+}
+/**
+ * Finds a locally available npm CLI script near the active Node runtime.
+ */
+function resolveNpmCliPath() {
+    const execDir = path.dirname(process.execPath);
+    const candidates = [
+        process.env.npm_execpath,
+        path.join(execDir, "node_modules", "npm", "bin", "npm-cli.js"),
+        path.join(execDir, "..", "node_modules", "npm", "bin", "npm-cli.js"),
+        path.join(execDir, "..", "..", "node_modules", "npm", "bin", "npm-cli.js"),
+    ];
+    for (const candidate of candidates) {
+        if (candidate && fs.existsSync(candidate)) {
+            return path.resolve(candidate);
+        }
+    }
+    return null;
 }

package/dist/runtime/copilot-sdk-loader.js

@@ -41,19 +41,19 @@ const copilot_installer_1 = require("./copilot-installer");
 /**
  * Dynamically resolves the lazily installed Copilot SDK entrypoint.
  */
-function getCopilotSdkEntrypoint() {
-    return path.join((0, copilot_installer_1.getCopilotRuntimeInstallDir)(), "node_modules", "@github", "copilot-sdk");
+function getCopilotSdkEntrypoint(runtimesDir) {
+    return path.join((0, copilot_installer_1.getCopilotRuntimeInstallDir)(runtimesDir), "node_modules", "@github", "copilot-sdk");
 }
 /**
  * Loads the Copilot SDK only when a Copilot runtime path is exercised.
  */
-async function loadCopilotSdk() {
-    const status = (0, copilot_installer_1.probeCopilotSdkInstall)();
+async function loadCopilotSdk(runtimesDir) {
+    const status = (0, copilot_installer_1.probeCopilotSdkInstall)(runtimesDir);
     if (!status.installed) {
         throw (0, errors_1.cliError)("COPILOT_SDK_MISSING", "The optional Copilot SDK runtime is not installed.", {
             installDir: status.installDir,
             packageName: status.packageName,
         });
     }
-    return Promise.resolve(`${getCopilotSdkEntrypoint()}`).then(s => __importStar(require(s)));
+    return Promise.resolve(`${getCopilotSdkEntrypoint(runtimesDir)}`).then(s => __importStar(require(s)));
 }

package/dist/storage/auth-repo.js

@@ -34,15 +34,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readAuthFileIfExists = readAuthFileIfExists;
-exports.buildManagedAuthPayload = buildManagedAuthPayload;
-exports.buildManagedAuthJson = buildManagedAuthJson;
-exports.writeAuthFile = writeAuthFile;
-exports.extractManagedAuthFingerprint = extractManagedAuthFingerprint;
-exports.readManagedAuthState = readManagedAuthState;
+exports.readAuthFileState = readAuthFileState;
+exports.writeOpenAiApiKeyAuth = writeOpenAiApiKeyAuth;
 const fs = __importStar(require("node:fs"));
 const errors_1 = require("../domain/errors");
-const fs_utils_1 = require("./fs-utils");
-const LEGACY_MANAGED_SECRET_KEYS = new Set(["api_key"]);
 /**
  * Reads auth.json when it exists and returns null otherwise.
  */
@@ -61,84 +56,27 @@ function readAuthFileIfExists(authPath) {
     }
 }
 /**
- * Builds the stable managed auth payload for one provider.
+ * Reads auth.json into a neutral file-state summary for status and doctor.
  */
-function buildManagedAuthPayload(provider) {
-    return {
-        auth_mode: "apikey",
-        [provider.envKey]: provider.apiKey,
-    };
-}
-/**
- * Builds the next auth.json object while preserving unmanaged metadata.
- */
-function buildManagedAuthJson(provider, existingAuthJson) {
-    const nextManaged = buildManagedAuthPayload(provider);
-    const result = {};
-    if (existingAuthJson && typeof existingAuthJson === "object" && !Array.isArray(existingAuthJson)) {
-        for (const [key, value] of Object.entries(existingAuthJson)) {
-            if (key === "auth_mode" || LEGACY_MANAGED_SECRET_KEYS.has(key) || looksLikeManagedSecretKey(key)) {
-                continue;
-            }
-            result[key] = value;
-        }
-    }
-    result.auth_mode = nextManaged.auth_mode;
-    result[provider.envKey] = provider.apiKey;
-    return result;
-}
-/**
- * Writes auth.json atomically using the managed mirror strategy.
- */
-function writeAuthFile(authPath, provider, existingAuthJson) {
-    (0, fs_utils_1.writeTextFileAtomic)(authPath, `${JSON.stringify(buildManagedAuthJson(provider, existingAuthJson), null, 2)}\n`);
-}
-/**
- * Extracts a lightweight fingerprint used by doctor/status.
- */
-function extractManagedAuthFingerprint(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input)) {
-        return {
-            authMode: null,
-            managedSecretKeys: [],
-            payload: null,
-        };
-    }
-    const payload = input;
-    const authMode = typeof payload.auth_mode === "string" ? payload.auth_mode : null;
-    const managedSecretKeys = Object.keys(payload)
-        .filter((key) => key !== "auth_mode" && looksLikeManagedSecretKey(key))
-        .sort();
-    return {
-        authMode,
-        managedSecretKeys,
-        payload,
-    };
-}
-/**
- * Reads auth.json into a doctor-friendly managed state summary.
- */
-function readManagedAuthState(authPath) {
+function readAuthFileState(authPath) {
     if (!fs.existsSync(authPath)) {
         return {
             exists: false,
             valid: false,
             parseError: null,
             authMode: null,
-            managedSecretKeys: [],
-            payload: null,
         };
     }
     try {
         const payload = readAuthFileIfExists(authPath);
-        const fingerprint = extractManagedAuthFingerprint(payload);
+        const authMode = payload && typeof payload === "object" && !Array.isArray(payload) && typeof payload.auth_mode === "string"
+            ? String(payload.auth_mode)
+            : null;
         return {
             exists: true,
-            valid: Boolean(fingerprint.payload),
+            valid: Boolean(payload && typeof payload === "object" && !Array.isArray(payload)),
             parseError: null,
-            authMode: fingerprint.authMode,
-            managedSecretKeys: fingerprint.managedSecretKeys,
-            payload: fingerprint.payload,
+            authMode,
         };
     }
     catch (error) {
@@ -147,14 +85,27 @@ function readManagedAuthState(authPath) {
             valid: false,
             parseError: (0, errors_1.normalizeError)(error).message,
             authMode: null,
-            managedSecretKeys: [],
-            payload: null,
         };
     }
 }
-function looksLikeManagedSecretKey(key) {
-    if (LEGACY_MANAGED_SECRET_KEYS.has(key)) {
-        return true;
+/**
+ * Writes the active direct-provider auth projection expected by Codex.
+ * Invalid or missing existing auth.json content is replaced with a minimal valid object.
+ */
+function writeOpenAiApiKeyAuth(authPath, apiKey) {
+    let next = {};
+    if (fs.existsSync(authPath)) {
+        try {
+            const payload = JSON.parse(fs.readFileSync(authPath, "utf8"));
+            if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+                next = { ...payload };
+            }
+        }
+        catch {
+            next = {};
+        }
     }
-    return /^[A-Z0-9_]+$/.test(key);
+    next.auth_mode = "apikey";
+    next.OPENAI_API_KEY = apiKey;
+    fs.writeFileSync(authPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }

package/dist/storage/backup-repo.js

@@ -47,7 +47,7 @@ const fs_utils_1 = require("./fs-utils");
 /**
  * Creates a point-in-time backup for the managed files involved in a mutation.
  */
-function createBackup(codexDir, backupsDir, reason, files) {
+function createBackup(backupsDir, reason, files) {
     try {
         const backupDir = path.join(backupsDir, `${createTimestamp()}-${reason}`);
         (0, fs_utils_1.ensureDir)(backupsDir);
@@ -62,6 +62,7 @@ function createBackup(codexDir, backupsDir, reason, files) {
             }
             entries.push({
                 relativePath: file.relativePath,
+                restorePath: file.absolutePath,
                 existed: exists,
                 backupFileName,
             });
@@ -70,7 +71,6 @@ function createBackup(codexDir, backupsDir, reason, files) {
             version: 1,
             createdAt: new Date().toISOString(),
             reason,
-            rootDir: codexDir,
             backupDir,
             files: entries,
         };
@@ -84,11 +84,11 @@ function createBackup(codexDir, backupsDir, reason, files) {
     }
 }
 /**
- * Restores all files described by a backup manifest back into the Codex directory.
+ * Restores all files described by a backup manifest back into their original paths.
  */
 function restoreManifest(manifest) {
     for (const entry of manifest.files) {
-        const targetPath = path.join(manifest.rootDir, entry.relativePath);
+        const targetPath = entry.restorePath;
         if (!entry.existed) {
             if (fs.existsSync(targetPath)) {
                 // Remove files that were created by the failed mutation but were absent before it.

package/dist/storage/codex-paths.js

@@ -33,17 +33,32 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CODEX_DIR_ENV_NAME = void 0;
+exports.TOOL_HOME_ENV_NAME = exports.CODEX_DIR_ENV_NAME = void 0;
+exports.resolveCodexSwitchHome = resolveCodexSwitchHome;
 exports.resolveCodexDir = resolveCodexDir;
 exports.createCodexPaths = createCodexPaths;
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 exports.CODEX_DIR_ENV_NAME = "CODEXS_CODEX_DIR";
+exports.TOOL_HOME_ENV_NAME = "CODEXS_HOME";
 const DEVELOPMENT_DEFAULT_CODEX_DIR = path.resolve(process.cwd(), "dev-codex", "local-sandbox");
 /**
- * Resolves the working Codex directory, defaulting to `~/.codex`.
+ * Resolves the tool home directory, defaulting to `~/.config/codex-switch`.
  */
-function resolveCodexDir(codexDir) {
+function resolveCodexSwitchHome(toolHomeDir) {
+    if (toolHomeDir) {
+        return path.resolve(toolHomeDir);
+    }
+    const envToolHome = process.env[exports.TOOL_HOME_ENV_NAME];
+    if (envToolHome) {
+        return path.resolve(envToolHome);
+    }
+    return path.join(os.homedir(), ".config", "codex-switch");
+}
+/**
+ * Resolves the working Codex directory using the documented precedence order.
+ */
+function resolveCodexDir(codexDir, toolConfig) {
     if (codexDir) {
         return path.resolve(codexDir);
     }
@@ -51,21 +66,32 @@ function resolveCodexDir(codexDir) {
     if (envCodexDir) {
         return path.resolve(envCodexDir);
     }
+    if (toolConfig?.defaultCodexDir) {
+        return path.resolve(toolConfig.defaultCodexDir);
+    }
     if (process.env.NODE_ENV === "development") {
         return DEVELOPMENT_DEFAULT_CODEX_DIR;
     }
     return path.join(os.homedir(), ".codex");
 }
 /**
- * Expands a Codex home directory into the file paths used by the CLI.
+ * Expands the tool home and Codex runtime into the file paths used by the CLI.
  */
-function createCodexPaths(codexDir) {
+function createCodexPaths(args) {
+    const input = typeof args === "string" ? { codexDir: args } : args;
+    const toolHomeDir = resolveCodexSwitchHome(input.toolHomeDir);
+    const codexDir = path.resolve(input.codexDir);
     return {
+        toolHomeDir,
+        toolConfigPath: path.join(toolHomeDir, "codex-switch.json"),
+        providersPath: path.join(toolHomeDir, "providers.json"),
+        backupsDir: path.join(toolHomeDir, "backups"),
+        latestBackupPath: path.join(toolHomeDir, "backups", "latest.json"),
+        lockPath: path.join(toolHomeDir, ".codex-switch.lock"),
+        runtimeDir: path.join(toolHomeDir, "runtime"),
+        runtimesDir: path.join(toolHomeDir, "runtimes"),
         codexDir,
         configPath: path.join(codexDir, "config.toml"),
-        providersPath: path.join(codexDir, "providers.json"),
         authPath: path.join(codexDir, "auth.json"),
-        backupsDir: path.join(codexDir, "backups"),
-        latestBackupPath: path.join(codexDir, "backups", "latest.json"),
     };
 }

package/dist/storage/config-repo.js

@@ -40,7 +40,6 @@ exports.listConfigProfiles = listConfigProfiles;
 exports.ensureProfileExists = ensureProfileExists;
 exports.requireManagedProfileRuntime = requireManagedProfileRuntime;
 exports.requireModelProviderRuntimeSection = requireModelProviderRuntimeSection;
-exports.requireRuntimeEnvKey = requireRuntimeEnvKey;
 exports.resolveActiveProviderName = resolveActiveProviderName;
 exports.updateTopLevelProfile = updateTopLevelProfile;
 exports.createConfigMutationPlan = createConfigMutationPlan;
@@ -143,13 +142,6 @@ function requireManagedProfileRuntime(document, providers, profile) {
             missingFields: ["base_url"],
         });
     }
-    if (!modelProviderSection.envKey) {
-        throw (0, errors_1.cliError)("MODEL_PROVIDER_ENV_KEY_MISSING", `Model provider "${view.modelProvider}" requires env_key.`, {
-            profile,
-            modelProvider: view.modelProvider,
-            missingFields: ["env_key"],
-        });
-    }
     return view;
 }
 /**
@@ -170,33 +162,6 @@ function requireModelProviderRuntimeSection(document, profile) {
             missingFields: ["base_url"],
         });
     }
-    if (!modelProviderSection.envKey) {
-        throw (0, errors_1.cliError)("MODEL_PROVIDER_ENV_KEY_MISSING", `Model provider "${profile}" requires env_key.`, {
-            profile,
-            modelProvider: profile,
-            missingFields: ["env_key"],
-        });
-    }
-}
-/**
- * Returns the runtime env_key for one profile or throws a typed error.
- */
-function requireRuntimeEnvKey(document, profile) {
-    const modelProviderSection = document.modelProviders.find((entry) => entry.name === profile);
-    if (!modelProviderSection) {
-        throw (0, errors_1.cliError)("PROFILE_NOT_FOUND", `Model provider "${profile}" does not exist in config.toml.`, {
-            profile,
-            modelProvider: profile,
-        });
-    }
-    if (!modelProviderSection.envKey) {
-        throw (0, errors_1.cliError)("MODEL_PROVIDER_ENV_KEY_MISSING", `Model provider "${profile}" requires env_key.`, {
-            profile,
-            modelProvider: profile,
-            missingFields: ["env_key"],
-        });
-    }
-    return modelProviderSection.envKey;
 }
 /**
  * Resolves the current active provider and requires the mapping to be unique.
@@ -212,7 +177,7 @@ function resolveActiveProviderName(document, providers) {
         });
     }
     if (matches.length > 1) {
-        throw (0, errors_1.cliError)("ACTIVE_PROVIDER_UNRESOLVED", `Active profile "${document.activeProfile}" maps to multiple providers.`, {
+        throw (0, errors_1.cliError)("ACTIVE_PROVIDER_UNRESOLVED", `Active profile "${document.activeProfile}" maps to multiple providers, so the active managed provider is ambiguous.`, {
             profile: document.activeProfile,
             providers: matches,
         });

package/dist/storage/lock-repo.js

@@ -35,15 +35,13 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withCodexLock = withCodexLock;
 const fs = __importStar(require("node:fs"));
-const path = __importStar(require("node:path"));
 const errors_1 = require("../domain/errors");
 const fs_utils_1 = require("./fs-utils");
 /**
  * Executes a mutation while holding an exclusive codex-switch lock file.
  */
-function withCodexLock(codexDir, operation, run) {
-    (0, fs_utils_1.ensureDir)(codexDir);
-    const lockPath = path.join(codexDir, ".codex-switch.lock");
+function withCodexLock(lockPath, operation, run) {
+    (0, fs_utils_1.ensureDir)(require("node:path").dirname(lockPath));
     acquireLock(lockPath, operation);
     try {
         return run();