@praeviso/code-env-switch 0.1.0 → 0.1.2

package/bin/config/defaults.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultProfiles = getDefaultProfiles;
+exports.deleteDefaultProfileEntry = deleteDefaultProfileEntry;
+exports.resolveDefaultProfileForType = resolveDefaultProfileForType;
+exports.getResolvedDefaultProfileKeys = getResolvedDefaultProfileKeys;
+exports.getTypeDefaultUnsetKeys = getTypeDefaultUnsetKeys;
+exports.getFilteredUnsetKeys = getFilteredUnsetKeys;
+const constants_1 = require("../constants");
+const type_1 = require("../profile/type");
+const resolve_1 = require("../profile/resolve");
+function getDefaultProfiles(config) {
+    const defaults = {};
+    if (!config || typeof config !== "object")
+        return defaults;
+    if (!config.defaultProfiles || typeof config.defaultProfiles !== "object") {
+        return defaults;
+    }
+    for (const [rawType, rawValue] of Object.entries(config.defaultProfiles)) {
+        const type = (0, type_1.normalizeType)(rawType);
+        if (!type)
+            continue;
+        const trimmed = String(rawValue !== null && rawValue !== void 0 ? rawValue : "").trim();
+        if (trimmed)
+            defaults[type] = trimmed;
+    }
+    return defaults;
+}
+function deleteDefaultProfileEntry(config, type) {
+    if (!config.defaultProfiles || typeof config.defaultProfiles !== "object") {
+        return false;
+    }
+    let changed = false;
+    for (const key of Object.keys(config.defaultProfiles)) {
+        if ((0, type_1.normalizeType)(key) === type) {
+            delete config.defaultProfiles[key];
+            changed = true;
+        }
+    }
+    return changed;
+}
+function resolveDefaultProfileForType(config, type, value) {
+    const trimmed = String(value !== null && value !== void 0 ? value : "").trim();
+    if (!trimmed)
+        return null;
+    const params = trimmed.split(/\s+/).filter(Boolean);
+    if (params.length === 0)
+        return null;
+    const explicitType = (0, type_1.normalizeType)(params[0]);
+    if (explicitType) {
+        if (explicitType !== type) {
+            throw new Error(`Default profile for "${type}" must match type "${type}".`);
+        }
+        return (0, resolve_1.resolveProfileName)(config, params);
+    }
+    return (0, resolve_1.resolveProfileName)(config, [type, ...params]);
+}
+function getResolvedDefaultProfileKeys(config) {
+    const defaults = getDefaultProfiles(config);
+    const resolved = {};
+    for (const type of constants_1.DEFAULT_PROFILE_TYPES) {
+        const value = defaults[type];
+        if (!value)
+            continue;
+        try {
+            const profileName = resolveDefaultProfileForType(config, type, value);
+            if (profileName)
+                resolved[type] = profileName;
+        }
+        catch (err) {
+            // ignore invalid defaults for list output
+        }
+    }
+    return resolved;
+}
+function getTypeDefaultUnsetKeys(type) {
+    return constants_1.DEFAULT_UNSET_KEYS[type] || [];
+}
+function getFilteredUnsetKeys(config, activeType) {
+    const keys = Array.isArray(config.unset) ? config.unset : [];
+    if (!activeType)
+        return [...keys];
+    const otherDefaults = new Set(constants_1.DEFAULT_PROFILE_TYPES.filter((type) => type !== activeType).flatMap((type) => constants_1.DEFAULT_UNSET_KEYS[type]));
+    return keys.filter((key) => !otherDefaults.has(key));
+}

package/bin/config/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilteredUnsetKeys = exports.getTypeDefaultUnsetKeys = exports.getResolvedDefaultProfileKeys = exports.resolveDefaultProfileForType = exports.deleteDefaultProfileEntry = exports.getDefaultProfiles = exports.writeConfig = exports.readConfigIfExists = exports.readConfig = exports.findConfigPathForWrite = exports.findConfigPath = exports.getDefaultConfigPath = void 0;
+/**
+ * Config module exports
+ */
+var io_1 = require("./io");
+Object.defineProperty(exports, "getDefaultConfigPath", { enumerable: true, get: function () { return io_1.getDefaultConfigPath; } });
+Object.defineProperty(exports, "findConfigPath", { enumerable: true, get: function () { return io_1.findConfigPath; } });
+Object.defineProperty(exports, "findConfigPathForWrite", { enumerable: true, get: function () { return io_1.findConfigPathForWrite; } });
+Object.defineProperty(exports, "readConfig", { enumerable: true, get: function () { return io_1.readConfig; } });
+Object.defineProperty(exports, "readConfigIfExists", { enumerable: true, get: function () { return io_1.readConfigIfExists; } });
+Object.defineProperty(exports, "writeConfig", { enumerable: true, get: function () { return io_1.writeConfig; } });
+var defaults_1 = require("./defaults");
+Object.defineProperty(exports, "getDefaultProfiles", { enumerable: true, get: function () { return defaults_1.getDefaultProfiles; } });
+Object.defineProperty(exports, "deleteDefaultProfileEntry", { enumerable: true, get: function () { return defaults_1.deleteDefaultProfileEntry; } });
+Object.defineProperty(exports, "resolveDefaultProfileForType", { enumerable: true, get: function () { return defaults_1.resolveDefaultProfileForType; } });
+Object.defineProperty(exports, "getResolvedDefaultProfileKeys", { enumerable: true, get: function () { return defaults_1.getResolvedDefaultProfileKeys; } });
+Object.defineProperty(exports, "getTypeDefaultUnsetKeys", { enumerable: true, get: function () { return defaults_1.getTypeDefaultUnsetKeys; } });
+Object.defineProperty(exports, "getFilteredUnsetKeys", { enumerable: true, get: function () { return defaults_1.getFilteredUnsetKeys; } });

package/bin/config/io.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultConfigPath = getDefaultConfigPath;
+exports.findConfigPath = findConfigPath;
+exports.findConfigPathForWrite = findConfigPathForWrite;
+exports.readConfig = readConfig;
+exports.readConfigIfExists = readConfigIfExists;
+exports.writeConfig = writeConfig;
+/**
+ * Config I/O utilities
+ */
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const utils_1 = require("../shell/utils");
+function getDefaultConfigPath() {
+    return path.join(os.homedir(), ".config", "code-env", "config.json");
+}
+function findConfigPath(explicitPath) {
+    if (explicitPath) {
+        const resolved = (0, utils_1.resolvePath)(explicitPath);
+        if (fs.existsSync(resolved))
+            return resolved;
+        return resolved; // let readConfig raise a helpful error
+    }
+    if (process.env.CODE_ENV_CONFIG) {
+        const fromEnv = (0, utils_1.resolvePath)(process.env.CODE_ENV_CONFIG);
+        if (fs.existsSync(fromEnv))
+            return fromEnv;
+        return fromEnv;
+    }
+    return getDefaultConfigPath();
+}
+function findConfigPathForWrite(explicitPath) {
+    if (explicitPath)
+        return (0, utils_1.resolvePath)(explicitPath);
+    if (process.env.CODE_ENV_CONFIG)
+        return (0, utils_1.resolvePath)(process.env.CODE_ENV_CONFIG);
+    return getDefaultConfigPath();
+}
+function readConfig(configPath) {
+    if (!configPath) {
+        throw new Error("No config file found. Use --config or set CODE_ENV_CONFIG.");
+    }
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    const raw = fs.readFileSync(configPath, "utf8");
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Invalid JSON in config: ${configPath}`);
+    }
+}
+function readConfigIfExists(configPath) {
+    if (!configPath || !fs.existsSync(configPath)) {
+        return { unset: [], profiles: {} };
+    }
+    return readConfig(configPath);
+}
+function writeConfig(configPath, config) {
+    if (!configPath) {
+        throw new Error("Missing config path for write.");
+    }
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const data = JSON.stringify(config, null, 2);
+    fs.writeFileSync(configPath, `${data}\n`, "utf8");
+}

package/bin/constants.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_UNSET_KEYS = exports.DEFAULT_PROFILE_TYPES = exports.CODEX_AUTH_PATH = void 0;
+/**
+ * Constants for codenv
+ */
+const path = require("path");
+const os = require("os");
+exports.CODEX_AUTH_PATH = path.join(os.homedir(), ".codex", "auth.json");
+exports.DEFAULT_PROFILE_TYPES = ["codex", "claude"];
+exports.DEFAULT_UNSET_KEYS = {
+    codex: [
+        "OPENAI_BASE_URL",
+        "OPENAI_API_KEY",
+        "CODE_ENV_PROFILE_KEY_CODEX",
+        "CODE_ENV_PROFILE_NAME_CODEX",
+        "CODE_ENV_CONFIG_PATH",
+    ],
+    claude: [
+        "ANTHROPIC_BASE_URL",
+        "ANTHROPIC_API_KEY",
+        "ANTHROPIC_AUTH_TOKEN",
+        "CODE_ENV_PROFILE_KEY_CLAUDE",
+        "CODE_ENV_PROFILE_NAME_CLAUDE",
+        "CODE_ENV_CONFIG_PATH",
+    ],
+};

package/bin/index.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * codenv - switch Claude/Codex env vars
+ * Main entry point
+ */
+const fs = require("fs");
+const constants_1 = require("./constants");
+const cli_1 = require("./cli");
+const shell_1 = require("./shell");
+const config_1 = require("./config");
+const profile_1 = require("./profile");
+const commands_1 = require("./commands");
+const usage_1 = require("./usage");
+const ui_1 = require("./ui");
+function getErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+async function main() {
+    const parsed = (0, cli_1.parseArgs)(process.argv.slice(2));
+    if (parsed.help) {
+        (0, cli_1.printHelp)();
+        return;
+    }
+    const args = parsed.args || [];
+    if (args.length === 0) {
+        (0, cli_1.printHelp)();
+        return;
+    }
+    const cmd = args[0];
+    try {
+        if (cmd === "init") {
+            const initArgs = (0, cli_1.parseInitArgs)(args.slice(1));
+            const shellName = (0, shell_1.detectShell)(initArgs.shell);
+            if (!shellName) {
+                throw new Error("Unknown shell. Use --shell <bash|zsh|fish> to specify.");
+            }
+            const snippet = (0, shell_1.getShellSnippet)(shellName);
+            if (initArgs.apply) {
+                const rcPath = (0, shell_1.getShellRcPath)(shellName);
+                (0, shell_1.upsertShellSnippet)(rcPath, snippet);
+                console.log(`Updated shell config: ${rcPath}`);
+            }
+            else {
+                console.log(snippet);
+            }
+            return;
+        }
+        if (cmd === "add") {
+            const writePath = (0, config_1.findConfigPathForWrite)(parsed.configPath);
+            const addArgsRaw = args.slice(1);
+            const hasInteractive = addArgsRaw.length === 0;
+            if (hasInteractive) {
+                await (0, ui_1.runInteractiveAdd)(writePath);
+                return;
+            }
+            const addArgsResult = (0, cli_1.parseAddArgs)(addArgsRaw);
+            const config = (0, config_1.readConfigIfExists)(writePath);
+            const updated = (0, commands_1.addConfig)(config, addArgsResult);
+            (0, config_1.writeConfig)(writePath, updated);
+            console.log(`Updated config: ${writePath}`);
+            return;
+        }
+        if (cmd === "auto") {
+            const configPath = (0, config_1.findConfigPath)(parsed.configPath);
+            if (!configPath || !fs.existsSync(configPath))
+                return;
+            const config = (0, config_1.readConfig)(configPath);
+            const defaults = (0, config_1.getDefaultProfiles)(config);
+            const hasDefaults = constants_1.DEFAULT_PROFILE_TYPES.some((type) => defaults[type]);
+            if (!hasDefaults)
+                return;
+            let includeGlobalUnset = true;
+            for (const type of constants_1.DEFAULT_PROFILE_TYPES) {
+                const value = defaults[type];
+                if (!value)
+                    continue;
+                try {
+                    const profileName = (0, config_1.resolveDefaultProfileForType)(config, type, value);
+                    if (!profileName)
+                        continue;
+                    (0, usage_1.logProfileUse)(config, configPath, profileName, type, process.env.CODE_ENV_TERMINAL_TAG || null, process.cwd());
+                    (0, commands_1.printUse)(config, profileName, type, includeGlobalUnset, configPath);
+                    includeGlobalUnset = false;
+                }
+                catch (err) {
+                    console.error(`codenv: ${getErrorMessage(err)}`);
+                }
+            }
+            return;
+        }
+        if (cmd === "launch") {
+            const params = args.slice(1);
+            if (params.length === 0) {
+                throw new Error("Missing launch target.");
+            }
+            const target = params[0];
+            const passArgs = params.slice(1);
+            if (passArgs[0] === "--")
+                passArgs.shift();
+            const configPath = process.env.CODE_ENV_CONFIG_PATH || (0, config_1.findConfigPath)(parsed.configPath);
+            const config = (0, config_1.readConfigIfExists)(configPath);
+            const exitCode = await (0, commands_1.runLaunch)(config, configPath, target, passArgs);
+            process.exit(exitCode);
+        }
+        if (cmd === "statusline") {
+            const statuslineArgs = (0, cli_1.parseStatuslineArgs)(args.slice(1));
+            const configPath = process.env.CODE_ENV_CONFIG_PATH || (0, config_1.findConfigPath)(parsed.configPath);
+            const config = (0, config_1.readConfigIfExists)(configPath);
+            (0, commands_1.printStatusline)(config, configPath, statuslineArgs);
+            return;
+        }
+        const configPath = (0, config_1.findConfigPath)(parsed.configPath);
+        const config = (0, config_1.readConfig)(configPath);
+        if (cmd === "default") {
+            const params = args.slice(1);
+            if (params.length === 0) {
+                throw new Error("Missing profile name.");
+            }
+            const clear = params.length === 1 &&
+                (params[0] === "--clear" || params[0] === "--unset");
+            if (clear) {
+                const rl = (0, ui_1.createReadline)();
+                try {
+                    const confirmed = await (0, ui_1.askConfirm)(rl, "Clear all default profiles? (y/N): ");
+                    if (!confirmed)
+                        return;
+                }
+                finally {
+                    rl.close();
+                }
+                let changed = false;
+                if (Object.prototype.hasOwnProperty.call(config, "defaultProfiles")) {
+                    delete config.defaultProfiles;
+                    changed = true;
+                }
+                if (changed) {
+                    (0, config_1.writeConfig)(configPath, config);
+                    console.log(`Updated config: ${configPath}`);
+                }
+                return;
+            }
+            const requestedType = params.length >= 2 ? (0, profile_1.normalizeType)(params[0]) : null;
+            const profileName = (0, profile_1.resolveProfileName)(config, params);
+            let targetType = requestedType;
+            if (!targetType) {
+                const profile = config.profiles && config.profiles[profileName];
+                targetType = (0, profile_1.inferProfileType)(profileName, profile, null);
+            }
+            if (!targetType) {
+                throw new Error("Unable to infer profile type. Use: codenv default <type> <name>.");
+            }
+            if (!config.defaultProfiles || typeof config.defaultProfiles !== "object") {
+                config.defaultProfiles = {};
+            }
+            config.defaultProfiles[targetType] = profileName;
+            (0, config_1.writeConfig)(configPath, config);
+            console.log(`Updated config: ${configPath}`);
+            return;
+        }
+        if (cmd === "remove") {
+            const params = args.slice(1);
+            if (params.length === 0) {
+                throw new Error("Missing profile name.");
+            }
+            const isAll = params.length === 1 && params[0] === "--all";
+            if (isAll) {
+                if (!config.profiles || typeof config.profiles !== "object") {
+                    config.profiles = {};
+                }
+                else {
+                    config.profiles = {};
+                }
+                if (Object.prototype.hasOwnProperty.call(config, "defaultProfiles")) {
+                    delete config.defaultProfiles;
+                }
+                (0, config_1.writeConfig)(configPath, config);
+                console.log(`Updated config: ${configPath}`);
+                return;
+            }
+            const targets = [];
+            const allPairs = params.length >= 2 &&
+                params.length % 2 === 0 &&
+                params.every((value, idx) => idx % 2 === 0 ? (0, profile_1.normalizeType)(value) : true);
+            if (allPairs) {
+                for (let i = 0; i < params.length; i += 2) {
+                    targets.push((0, profile_1.resolveProfileName)(config, params.slice(i, i + 2)));
+                }
+            }
+            else {
+                for (const param of params) {
+                    targets.push((0, profile_1.resolveProfileName)(config, [param]));
+                }
+            }
+            const uniqueTargets = Array.from(new Set(targets));
+            const missing = uniqueTargets.filter((name) => !config.profiles || !config.profiles[name]);
+            if (missing.length > 0) {
+                throw new Error(`Unknown profile(s): ${missing.join(", ")}`);
+            }
+            for (const name of uniqueTargets) {
+                delete config.profiles[name];
+            }
+            const defaults = (0, config_1.getDefaultProfiles)(config);
+            let changedDefaults = false;
+            for (const type of constants_1.DEFAULT_PROFILE_TYPES) {
+                const value = defaults[type];
+                if (!value)
+                    continue;
+                try {
+                    const resolved = (0, config_1.resolveDefaultProfileForType)(config, type, value);
+                    if (resolved && uniqueTargets.includes(resolved)) {
+                        if ((0, config_1.deleteDefaultProfileEntry)(config, type)) {
+                            changedDefaults = true;
+                        }
+                    }
+                }
+                catch (err) {
+                    // keep defaults that cannot be resolved
+                }
+            }
+            if (changedDefaults &&
+                config.defaultProfiles &&
+                Object.keys(config.defaultProfiles).length === 0) {
+                delete config.defaultProfiles;
+            }
+            (0, config_1.writeConfig)(configPath, config);
+            console.log(`Updated config: ${configPath}`);
+            return;
+        }
+        if (cmd === "config") {
+            const cfgPath = (0, config_1.findConfigPath)(parsed.configPath);
+            if (!cfgPath) {
+                console.log("(no config found)");
+                return;
+            }
+            console.log(cfgPath);
+            return;
+        }
+        if (cmd === "list" || cmd === "ls") {
+            (0, commands_1.printList)(config, configPath);
+            return;
+        }
+        if (cmd === "use") {
+            const params = args.slice(1);
+            if (params.length === 0) {
+                const printUseWithLog = (cfg, profileName, requestedType) => {
+                    (0, usage_1.logProfileUse)(cfg, configPath, profileName, requestedType, process.env.CODE_ENV_TERMINAL_TAG || null, process.cwd());
+                    (0, commands_1.printUse)(cfg, profileName, requestedType, true, configPath);
+                };
+                await (0, ui_1.runInteractiveUse)(config, printUseWithLog);
+                return;
+            }
+            const requestedType = params.length >= 2 ? (0, profile_1.normalizeType)(params[0]) : null;
+            const profileName = (0, profile_1.resolveProfileName)(config, params);
+            (0, usage_1.logProfileUse)(config, configPath, profileName, requestedType, process.env.CODE_ENV_TERMINAL_TAG || null, process.cwd());
+            (0, commands_1.printUse)(config, profileName, requestedType, true, configPath);
+            return;
+        }
+        if (cmd === "show") {
+            const profileName = (0, profile_1.resolveProfileName)(config, args.slice(1));
+            (0, commands_1.printShow)(config, profileName);
+            return;
+        }
+        if (cmd === "unset") {
+            (0, commands_1.printUnset)(config);
+            return;
+        }
+        throw new Error(`Unknown command: ${cmd}`);
+    }
+    catch (err) {
+        console.error(`codenv: ${getErrorMessage(err)}`);
+        process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error(`codenv: ${getErrorMessage(err)}`);
+    process.exit(1);
+});

package/bin/profile/display.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnvValueUnset = isEnvValueUnset;
+exports.buildEffectiveEnv = buildEffectiveEnv;
+exports.envMatchesProfile = envMatchesProfile;
+exports.buildListRows = buildListRows;
+const constants_1 = require("../constants");
+const type_1 = require("./type");
+function isEnvValueUnset(value) {
+    return value === null || value === undefined || value === "";
+}
+function buildEffectiveEnv(profile, activeType) {
+    const env = profile && profile.env ? profile.env : {};
+    if (!activeType)
+        return env;
+    if (activeType !== "claude")
+        return env;
+    const apiKey = env.ANTHROPIC_API_KEY;
+    const authToken = env.ANTHROPIC_AUTH_TOKEN;
+    if (isEnvValueUnset(apiKey) || !isEnvValueUnset(authToken))
+        return env;
+    return { ...env, ANTHROPIC_AUTH_TOKEN: apiKey };
+}
+function envMatchesProfile(profile) {
+    if (!profile || !profile.env)
+        return false;
+    for (const key of Object.keys(profile.env)) {
+        const expected = profile.env[key];
+        const actual = process.env[key];
+        if (isEnvValueUnset(expected)) {
+            if (actual !== undefined && actual !== "")
+                return false;
+            continue;
+        }
+        if (actual !== String(expected))
+            return false;
+    }
+    return Object.keys(profile.env).length > 0;
+}
+// Forward declaration to avoid circular dependency
+// getResolvedDefaultProfileKeys will be imported from config/defaults
+function buildListRows(config, getResolvedDefaultProfileKeys) {
+    const profiles = config && config.profiles ? config.profiles : {};
+    const entries = Object.entries(profiles);
+    if (entries.length === 0)
+        return [];
+    const defaults = getResolvedDefaultProfileKeys(config);
+    const rows = entries.map(([key, profile]) => {
+        const safeProfile = profile || {};
+        const rawType = safeProfile.type ? String(safeProfile.type) : "";
+        const normalizedType = (0, type_1.normalizeType)(rawType);
+        const type = normalizedType || rawType || "-";
+        const inferredType = (0, type_1.inferProfileType)(key, safeProfile, null);
+        const usageType = inferredType || normalizedType || null;
+        const displayName = (0, type_1.getProfileDisplayName)(key, safeProfile);
+        const note = safeProfile.note ? String(safeProfile.note) : "";
+        const defaultTypes = constants_1.DEFAULT_PROFILE_TYPES.filter((profileType) => defaults[profileType] === key);
+        const defaultLabel = defaultTypes.length > 0 ? "default" : "";
+        const noteParts = [];
+        if (defaultLabel)
+            noteParts.push(defaultLabel);
+        if (note)
+            noteParts.push(note);
+        const noteText = noteParts.join(" | ");
+        const active = envMatchesProfile(safeProfile);
+        return { key, name: displayName, type, note: noteText, active, usageType };
+    });
+    rows.sort((a, b) => {
+        const nameCmp = a.name.localeCompare(b.name);
+        if (nameCmp !== 0)
+            return nameCmp;
+        const typeCmp = a.type.localeCompare(b.type);
+        if (typeCmp !== 0)
+            return typeCmp;
+        return a.key.localeCompare(b.key);
+    });
+    return rows;
+}

package/bin/profile/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildListRows = exports.envMatchesProfile = exports.buildEffectiveEnv = exports.isEnvValueUnset = exports.resolveProfileByType = exports.resolveProfileName = exports.generateProfileKey = exports.shouldRemoveCodexAuth = exports.findProfileKeysByName = exports.profileMatchesType = exports.getProfileDisplayName = exports.stripTypePrefixFromName = exports.inferProfileType = exports.hasEnvKeyPrefix = exports.hasTypePrefix = exports.normalizeType = void 0;
+/**
+ * Profile module exports
+ */
+var type_1 = require("./type");
+Object.defineProperty(exports, "normalizeType", { enumerable: true, get: function () { return type_1.normalizeType; } });
+Object.defineProperty(exports, "hasTypePrefix", { enumerable: true, get: function () { return type_1.hasTypePrefix; } });
+Object.defineProperty(exports, "hasEnvKeyPrefix", { enumerable: true, get: function () { return type_1.hasEnvKeyPrefix; } });
+Object.defineProperty(exports, "inferProfileType", { enumerable: true, get: function () { return type_1.inferProfileType; } });
+Object.defineProperty(exports, "stripTypePrefixFromName", { enumerable: true, get: function () { return type_1.stripTypePrefixFromName; } });
+Object.defineProperty(exports, "getProfileDisplayName", { enumerable: true, get: function () { return type_1.getProfileDisplayName; } });
+var match_1 = require("./match");
+Object.defineProperty(exports, "profileMatchesType", { enumerable: true, get: function () { return match_1.profileMatchesType; } });
+Object.defineProperty(exports, "findProfileKeysByName", { enumerable: true, get: function () { return match_1.findProfileKeysByName; } });
+Object.defineProperty(exports, "shouldRemoveCodexAuth", { enumerable: true, get: function () { return match_1.shouldRemoveCodexAuth; } });
+var resolve_1 = require("./resolve");
+Object.defineProperty(exports, "generateProfileKey", { enumerable: true, get: function () { return resolve_1.generateProfileKey; } });
+Object.defineProperty(exports, "resolveProfileName", { enumerable: true, get: function () { return resolve_1.resolveProfileName; } });
+Object.defineProperty(exports, "resolveProfileByType", { enumerable: true, get: function () { return resolve_1.resolveProfileByType; } });
+var display_1 = require("./display");
+Object.defineProperty(exports, "isEnvValueUnset", { enumerable: true, get: function () { return display_1.isEnvValueUnset; } });
+Object.defineProperty(exports, "buildEffectiveEnv", { enumerable: true, get: function () { return display_1.buildEffectiveEnv; } });
+Object.defineProperty(exports, "envMatchesProfile", { enumerable: true, get: function () { return display_1.envMatchesProfile; } });
+Object.defineProperty(exports, "buildListRows", { enumerable: true, get: function () { return display_1.buildListRows; } });

package/bin/profile/match.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profileMatchesType = profileMatchesType;
+exports.findProfileKeysByName = findProfileKeysByName;
+exports.shouldRemoveCodexAuth = shouldRemoveCodexAuth;
+const type_1 = require("./type");
+function profileMatchesType(profile, type) {
+    if (!profile)
+        return false;
+    if (!profile.type)
+        return true;
+    const t = (0, type_1.normalizeType)(profile.type);
+    if (!t)
+        return false;
+    return t === type;
+}
+function findProfileKeysByName(config, name, type) {
+    const profiles = config && config.profiles ? config.profiles : {};
+    const matches = [];
+    for (const [key, profile] of Object.entries(profiles)) {
+        const safeProfile = profile || {};
+        if (type && !profileMatchesType(safeProfile, type))
+            continue;
+        const displayName = (0, type_1.getProfileDisplayName)(key, safeProfile, type || null);
+        if (displayName === name)
+            matches.push(key);
+    }
+    return matches;
+}
+function shouldRemoveCodexAuth(profileName, profile, requestedType) {
+    if (requestedType === "codex")
+        return true;
+    if (!profile)
+        return false;
+    if ((0, type_1.normalizeType)(profile.type) === "codex")
+        return true;
+    if ((0, type_1.hasEnvKeyPrefix)(profile, "OPENAI_"))
+        return true;
+    return (0, type_1.hasTypePrefix)(profileName, "codex");
+}