@praeviso/code-env-switch 0.1.1 → 0.1.2

package/src/config/defaults.ts

@@ -0,0 +1,88 @@
+/**
+ * Default profile handling
+ */
+import type { Config, ProfileType, DefaultProfiles } from "../types";
+import { DEFAULT_PROFILE_TYPES, DEFAULT_UNSET_KEYS } from "../constants";
+import { normalizeType } from "../profile/type";
+import { resolveProfileName } from "../profile/resolve";
+
+export function getDefaultProfiles(config: Config): DefaultProfiles {
+    const defaults: DefaultProfiles = {};
+    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 = normalizeType(rawType);
+        if (!type) continue;
+        const trimmed = String(rawValue ?? "").trim();
+        if (trimmed) defaults[type] = trimmed;
+    }
+    return defaults;
+}
+
+export function deleteDefaultProfileEntry(config: Config, type: ProfileType): boolean {
+    if (!config.defaultProfiles || typeof config.defaultProfiles !== "object") {
+        return false;
+    }
+    let changed = false;
+    for (const key of Object.keys(config.defaultProfiles)) {
+        if (normalizeType(key) === type) {
+            delete config.defaultProfiles[key];
+            changed = true;
+        }
+    }
+    return changed;
+}
+
+export function resolveDefaultProfileForType(
+    config: Config,
+    type: ProfileType,
+    value: string
+): string | null {
+    const trimmed = String(value ?? "").trim();
+    if (!trimmed) return null;
+    const params = trimmed.split(/\s+/).filter(Boolean);
+    if (params.length === 0) return null;
+    const explicitType = normalizeType(params[0]);
+    if (explicitType) {
+        if (explicitType !== type) {
+            throw new Error(
+                `Default profile for "${type}" must match type "${type}".`
+            );
+        }
+        return resolveProfileName(config, params);
+    }
+    return resolveProfileName(config, [type, ...params]);
+}
+
+export function getResolvedDefaultProfileKeys(config: Config): DefaultProfiles {
+    const defaults = getDefaultProfiles(config);
+    const resolved: DefaultProfiles = {};
+    for (const type of 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;
+}
+
+export function getTypeDefaultUnsetKeys(type: ProfileType): string[] {
+    return DEFAULT_UNSET_KEYS[type] || [];
+}
+
+export function getFilteredUnsetKeys(config: Config, activeType: ProfileType | null): string[] {
+    const keys = Array.isArray(config.unset) ? config.unset : [];
+    if (!activeType) return [...keys];
+    const otherDefaults = new Set(
+        DEFAULT_PROFILE_TYPES.filter((type) => type !== activeType).flatMap(
+            (type) => DEFAULT_UNSET_KEYS[type]
+        )
+    );
+    return keys.filter((key) => !otherDefaults.has(key));
+}

package/src/config/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Config module exports
+ */
+export {
+    getDefaultConfigPath,
+    findConfigPath,
+    findConfigPathForWrite,
+    readConfig,
+    readConfigIfExists,
+    writeConfig,
+} from "./io";
+export {
+    getDefaultProfiles,
+    deleteDefaultProfileEntry,
+    resolveDefaultProfileForType,
+    getResolvedDefaultProfileKeys,
+    getTypeDefaultUnsetKeys,
+    getFilteredUnsetKeys,
+} from "./defaults";

package/src/config/io.ts

@@ -0,0 +1,69 @@
+/**
+ * Config I/O utilities
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import type { Config } from "../types";
+import { resolvePath } from "../shell/utils";
+
+export function getDefaultConfigPath(): string {
+    return path.join(os.homedir(), ".config", "code-env", "config.json");
+}
+
+export function findConfigPath(explicitPath: string | null): string | null {
+    if (explicitPath) {
+        const resolved = resolvePath(explicitPath);
+        if (fs.existsSync(resolved)) return resolved;
+        return resolved; // let readConfig raise a helpful error
+    }
+
+    if (process.env.CODE_ENV_CONFIG) {
+        const fromEnv = resolvePath(process.env.CODE_ENV_CONFIG);
+        if (fs.existsSync(fromEnv)) return fromEnv;
+        return fromEnv;
+    }
+    return getDefaultConfigPath();
+}
+
+export function findConfigPathForWrite(explicitPath: string | null): string {
+    if (explicitPath) return resolvePath(explicitPath)!;
+    if (process.env.CODE_ENV_CONFIG) return resolvePath(process.env.CODE_ENV_CONFIG)!;
+    return getDefaultConfigPath();
+}
+
+export function readConfig(configPath: string): Config {
+    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}`);
+    }
+}
+
+export function readConfigIfExists(configPath: string | null): Config {
+    if (!configPath || !fs.existsSync(configPath)) {
+        return { unset: [], profiles: {} };
+    }
+    return readConfig(configPath);
+}
+
+export function writeConfig(configPath: string, config: Config): void {
+    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/src/constants.ts

@@ -0,0 +1,28 @@
+/**
+ * Constants for codenv
+ */
+import * as path from "path";
+import * as os from "os";
+import type { ProfileType } from "./types";
+
+export const CODEX_AUTH_PATH = path.join(os.homedir(), ".codex", "auth.json");
+
+export const DEFAULT_PROFILE_TYPES: ProfileType[] = ["codex", "claude"];
+
+export const DEFAULT_UNSET_KEYS: Record<ProfileType, string[]> = {
+    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/src/index.ts

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+/**
+ * codenv - switch Claude/Codex env vars
+ * Main entry point
+ */
+import * as fs from "fs";
+import type { Config, ProfileType } from "./types";
+import { DEFAULT_PROFILE_TYPES } from "./constants";
+import {
+    parseArgs,
+    parseInitArgs,
+    parseAddArgs,
+    parseStatuslineArgs,
+    printHelp,
+} from "./cli";
+import { detectShell, getShellRcPath, getShellSnippet, upsertShellSnippet } from "./shell";
+import {
+    findConfigPath,
+    findConfigPathForWrite,
+    readConfig,
+    readConfigIfExists,
+    writeConfig,
+    getDefaultProfiles,
+    deleteDefaultProfileEntry,
+    resolveDefaultProfileForType,
+} from "./config";
+import { normalizeType, inferProfileType, resolveProfileName } from "./profile";
+import {
+    addConfig,
+    printList,
+    printShow,
+    printUse,
+    printUnset,
+    runLaunch,
+    printStatusline,
+} from "./commands";
+import { logProfileUse } from "./usage";
+import { createReadline, askConfirm, runInteractiveAdd, runInteractiveUse } from "./ui";
+
+function getErrorMessage(err: unknown): string {
+    return err instanceof Error ? err.message : String(err);
+}
+
+async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    if (parsed.help) {
+        printHelp();
+        return;
+    }
+
+    const args = parsed.args || [];
+
+    if (args.length === 0) {
+        printHelp();
+        return;
+    }
+
+    const cmd = args[0];
+    try {
+        if (cmd === "init") {
+            const initArgs = parseInitArgs(args.slice(1));
+            const shellName = detectShell(initArgs.shell);
+            if (!shellName) {
+                throw new Error(
+                    "Unknown shell. Use --shell <bash|zsh|fish> to specify."
+                );
+            }
+            const snippet = getShellSnippet(shellName);
+            if (initArgs.apply) {
+                const rcPath = getShellRcPath(shellName);
+                upsertShellSnippet(rcPath!, snippet);
+                console.log(`Updated shell config: ${rcPath}`);
+            } else {
+                console.log(snippet);
+            }
+            return;
+        }
+
+        if (cmd === "add") {
+            const writePath = findConfigPathForWrite(parsed.configPath);
+            const addArgsRaw = args.slice(1);
+            const hasInteractive = addArgsRaw.length === 0;
+            if (hasInteractive) {
+                await runInteractiveAdd(writePath);
+                return;
+            }
+            const addArgsResult = parseAddArgs(addArgsRaw);
+            const config = readConfigIfExists(writePath);
+            const updated = addConfig(config, addArgsResult);
+            writeConfig(writePath, updated);
+            console.log(`Updated config: ${writePath}`);
+            return;
+        }
+
+        if (cmd === "auto") {
+            const configPath = findConfigPath(parsed.configPath);
+            if (!configPath || !fs.existsSync(configPath)) return;
+            const config = readConfig(configPath);
+            const defaults = getDefaultProfiles(config);
+            const hasDefaults = DEFAULT_PROFILE_TYPES.some((type) => defaults[type]);
+            if (!hasDefaults) return;
+
+            let includeGlobalUnset = true;
+            for (const type of DEFAULT_PROFILE_TYPES) {
+                const value = defaults[type];
+                if (!value) continue;
+                try {
+                    const profileName = resolveDefaultProfileForType(
+                        config,
+                        type,
+                        value
+                    );
+                    if (!profileName) continue;
+                    logProfileUse(
+                        config,
+                        configPath,
+                        profileName,
+                        type,
+                        process.env.CODE_ENV_TERMINAL_TAG || null,
+                        process.cwd()
+                    );
+                    printUse(config, profileName, type, includeGlobalUnset, configPath);
+                    includeGlobalUnset = false;
+                } catch (err: unknown) {
+                    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 || findConfigPath(parsed.configPath);
+            const config = readConfigIfExists(configPath);
+            const exitCode = await runLaunch(config, configPath, target, passArgs);
+            process.exit(exitCode);
+        }
+
+        if (cmd === "statusline") {
+            const statuslineArgs = parseStatuslineArgs(args.slice(1));
+            const configPath =
+                process.env.CODE_ENV_CONFIG_PATH || findConfigPath(parsed.configPath);
+            const config = readConfigIfExists(configPath);
+            printStatusline(config, configPath, statuslineArgs);
+            return;
+        }
+
+        const configPath = findConfigPath(parsed.configPath);
+        const config = 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 = createReadline();
+                try {
+                    const confirmed = await 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) {
+                    writeConfig(configPath!, config);
+                    console.log(`Updated config: ${configPath}`);
+                }
+                return;
+            }
+            const requestedType =
+                params.length >= 2 ? normalizeType(params[0]) : null;
+            const profileName = resolveProfileName(config, params);
+            let targetType = requestedType;
+            if (!targetType) {
+                const profile = config.profiles && config.profiles[profileName];
+                targetType = 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;
+            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;
+                }
+                writeConfig(configPath!, config);
+                console.log(`Updated config: ${configPath}`);
+                return;
+            }
+
+            const targets: string[] = [];
+            const allPairs =
+                params.length >= 2 &&
+                params.length % 2 === 0 &&
+                params.every((value, idx) =>
+                    idx % 2 === 0 ? normalizeType(value) : true
+                );
+            if (allPairs) {
+                for (let i = 0; i < params.length; i += 2) {
+                    targets.push(resolveProfileName(config, params.slice(i, i + 2)));
+                }
+            } else {
+                for (const param of params) {
+                    targets.push(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 = getDefaultProfiles(config);
+            let changedDefaults = false;
+            for (const type of DEFAULT_PROFILE_TYPES) {
+                const value = defaults[type];
+                if (!value) continue;
+                try {
+                    const resolved = resolveDefaultProfileForType(config, type, value);
+                    if (resolved && uniqueTargets.includes(resolved)) {
+                        if (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;
+            }
+            writeConfig(configPath!, config);
+            console.log(`Updated config: ${configPath}`);
+            return;
+        }
+
+        if (cmd === "config") {
+            const cfgPath = findConfigPath(parsed.configPath);
+            if (!cfgPath) {
+                console.log("(no config found)");
+                return;
+            }
+            console.log(cfgPath);
+            return;
+        }
+
+        if (cmd === "list" || cmd === "ls") {
+            printList(config, configPath);
+            return;
+        }
+
+        if (cmd === "use") {
+            const params = args.slice(1);
+            if (params.length === 0) {
+                const printUseWithLog = (
+                    cfg: Config,
+                    profileName: string,
+                    requestedType: ProfileType | null
+                ) => {
+                    logProfileUse(
+                        cfg,
+                        configPath,
+                        profileName,
+                        requestedType,
+                        process.env.CODE_ENV_TERMINAL_TAG || null,
+                        process.cwd()
+                    );
+                    printUse(cfg, profileName, requestedType, true, configPath);
+                };
+                await runInteractiveUse(config, printUseWithLog);
+                return;
+            }
+            const requestedType =
+                params.length >= 2 ? normalizeType(params[0]) : null;
+            const profileName = resolveProfileName(config, params);
+            logProfileUse(
+                config,
+                configPath,
+                profileName,
+                requestedType,
+                process.env.CODE_ENV_TERMINAL_TAG || null,
+                process.cwd()
+            );
+            printUse(config, profileName, requestedType, true, configPath);
+            return;
+        }
+
+        if (cmd === "show") {
+            const profileName = resolveProfileName(config, args.slice(1));
+            printShow(config, profileName);
+            return;
+        }
+
+        if (cmd === "unset") {
+            printUnset(config);
+            return;
+        }
+
+        throw new Error(`Unknown command: ${cmd}`);
+    } catch (err: unknown) {
+        console.error(`codenv: ${getErrorMessage(err)}`);
+        process.exit(1);
+    }
+}
+
+main().catch((err: unknown) => {
+    console.error(`codenv: ${getErrorMessage(err)}`);
+    process.exit(1);
+});

package/src/profile/display.ts

@@ -0,0 +1,77 @@
+/**
+ * Profile display utilities
+ */
+import type { Config, Profile, ProfileType, ListRow, EnvValue } from "../types";
+import { DEFAULT_PROFILE_TYPES } from "../constants";
+import { normalizeType, inferProfileType, getProfileDisplayName } from "./type";
+
+export function isEnvValueUnset(value: EnvValue): boolean {
+    return value === null || value === undefined || value === "";
+}
+
+export function buildEffectiveEnv(
+    profile: Profile | undefined,
+    activeType: ProfileType | null
+): Record<string, EnvValue> {
+    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 };
+}
+
+export function envMatchesProfile(profile: Profile | undefined): boolean {
+    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
+export function buildListRows(
+    config: Config,
+    getResolvedDefaultProfileKeys: (config: Config) => Record<string, string | undefined>
+): ListRow[] {
+    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 = normalizeType(rawType);
+        const type = normalizedType || rawType || "-";
+        const inferredType = inferProfileType(key, safeProfile, null);
+        const usageType = inferredType || normalizedType || null;
+        const displayName = getProfileDisplayName(key, safeProfile);
+        const note = safeProfile.note ? String(safeProfile.note) : "";
+        const defaultTypes = DEFAULT_PROFILE_TYPES.filter(
+            (profileType) => defaults[profileType] === key
+        );
+        const defaultLabel = defaultTypes.length > 0 ? "default" : "";
+        const noteParts: string[] = [];
+        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/src/profile/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Profile module exports
+ */
+export { normalizeType, hasTypePrefix, hasEnvKeyPrefix, inferProfileType, stripTypePrefixFromName, getProfileDisplayName } from "./type";
+export { profileMatchesType, findProfileKeysByName, shouldRemoveCodexAuth } from "./match";
+export { generateProfileKey, resolveProfileName, resolveProfileByType } from "./resolve";
+export {
+    isEnvValueUnset,
+    buildEffectiveEnv,
+    envMatchesProfile,
+    buildListRows,
+} from "./display";

package/src/profile/match.ts

@@ -0,0 +1,41 @@
+/**
+ * Profile matching utilities
+ */
+import type { Config, Profile, ProfileType } from "../types";
+import { normalizeType, hasEnvKeyPrefix, hasTypePrefix, getProfileDisplayName } from "./type";
+
+export function profileMatchesType(profile: Profile | undefined, type: ProfileType): boolean {
+    if (!profile) return false;
+    if (!profile.type) return true;
+    const t = normalizeType(profile.type);
+    if (!t) return false;
+    return t === type;
+}
+
+export function findProfileKeysByName(
+    config: Config,
+    name: string,
+    type?: ProfileType | null
+): string[] {
+    const profiles = config && config.profiles ? config.profiles : {};
+    const matches: string[] = [];
+    for (const [key, profile] of Object.entries(profiles)) {
+        const safeProfile = profile || {};
+        if (type && !profileMatchesType(safeProfile, type)) continue;
+        const displayName = getProfileDisplayName(key, safeProfile, type || null);
+        if (displayName === name) matches.push(key);
+    }
+    return matches;
+}
+
+export function shouldRemoveCodexAuth(
+    profileName: string,
+    profile: Profile | undefined,
+    requestedType: ProfileType | null
+): boolean {
+    if (requestedType === "codex") return true;
+    if (!profile) return false;
+    if (normalizeType(profile.type) === "codex") return true;
+    if (hasEnvKeyPrefix(profile, "OPENAI_")) return true;
+    return hasTypePrefix(profileName, "codex");
+}