@praeviso/code-env-switch 0.1.1 → 0.1.3

package/bin/ui/interactive.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInteractiveAdd = runInteractiveAdd;
+exports.runInteractiveUse = runInteractiveUse;
+/**
+ * Interactive UI components
+ */
+const readline = require("readline");
+const config_1 = require("../config");
+const resolve_1 = require("../profile/resolve");
+const type_1 = require("../profile/type");
+const display_1 = require("../profile/display");
+const readline_1 = require("./readline");
+async function runInteractiveAdd(configPath) {
+    const config = (0, config_1.readConfigIfExists)(configPath);
+    const rl = (0, readline_1.createReadline)();
+    try {
+        const type = await (0, readline_1.askType)(rl);
+        const defaultName = "default";
+        const profileInfo = await (0, readline_1.askProfileName)(rl, config, defaultName, type);
+        const profileKey = profileInfo.key || (0, resolve_1.generateProfileKey)(config);
+        const baseUrl = await (0, readline_1.askRequired)(rl, "Base URL (required): ");
+        const apiKey = await (0, readline_1.askRequired)(rl, "API key (required): ");
+        if (!config.profiles || typeof config.profiles !== "object") {
+            config.profiles = {};
+        }
+        if (!config.profiles[profileKey]) {
+            config.profiles[profileKey] = {};
+        }
+        const profile = config.profiles[profileKey];
+        profile.name = profileInfo.name;
+        profile.type = type;
+        if (!profile.env || typeof profile.env !== "object") {
+            profile.env = {};
+        }
+        if (type === "codex") {
+            profile.env.OPENAI_BASE_URL = baseUrl;
+            profile.env.OPENAI_API_KEY = apiKey;
+        }
+        else {
+            profile.env.ANTHROPIC_BASE_URL = baseUrl;
+            profile.env.ANTHROPIC_API_KEY = apiKey;
+            console.log("Note: ANTHROPIC_AUTH_TOKEN will be set to the same value when applying.");
+        }
+        (0, config_1.writeConfig)(configPath, config);
+        console.log(`Updated config: ${configPath}`);
+    }
+    finally {
+        rl.close();
+    }
+}
+async function runInteractiveUse(config, printUse) {
+    if (!process.stdin.isTTY || !process.stderr.isTTY) {
+        throw new Error("Interactive selection requires a TTY. Provide a profile name.");
+    }
+    const rows = (0, display_1.buildListRows)(config, config_1.getResolvedDefaultProfileKeys);
+    if (rows.length === 0) {
+        throw new Error("No profiles found.");
+    }
+    const nameTypeCounts = new Map();
+    for (const row of rows) {
+        const key = `${row.name}||${row.type}`;
+        nameTypeCounts.set(key, (nameTypeCounts.get(key) || 0) + 1);
+    }
+    const displayRows = rows.map((row) => {
+        const key = `${row.name}||${row.type}`;
+        const displayName = (nameTypeCounts.get(key) || 0) > 1 ? `${row.name} [${row.key}]` : row.name;
+        const noteText = row.note;
+        const profile = config.profiles && config.profiles[row.key];
+        const inferredType = (0, type_1.inferProfileType)(row.key, profile, null);
+        const resolvedType = inferredType || (0, type_1.normalizeType)(row.type) || null;
+        return { ...row, displayName, noteText, resolvedType };
+    });
+    const headerName = "PROFILE";
+    const headerType = "TYPE";
+    const headerNote = "NOTE";
+    const nameWidth = Math.max(headerName.length, ...displayRows.map((row) => row.displayName.length));
+    const typeWidth = Math.max(headerType.length, ...displayRows.map((row) => row.type.length));
+    const noteWidth = Math.max(headerNote.length, ...displayRows.map((row) => row.noteText.length));
+    const formatRow = (name, type, note) => `${name.padEnd(nameWidth)}  ${type.padEnd(typeWidth)}  ${note.padEnd(noteWidth)}`;
+    const activeKeys = new Set();
+    const keyToType = new Map();
+    for (const row of displayRows) {
+        keyToType.set(row.key, row.resolvedType || null);
+        if (row.active)
+            activeKeys.add(row.key);
+    }
+    let index = displayRows.findIndex((row) => row.active);
+    if (index < 0)
+        index = 0;
+    const ANSI_CLEAR = "\x1b[2J\x1b[H";
+    const ANSI_HIDE_CURSOR = "\x1b[?25l";
+    const ANSI_SHOW_CURSOR = "\x1b[?25h";
+    const ANSI_INVERT = "\x1b[7m";
+    const ANSI_GREEN = "\x1b[32m";
+    const ANSI_RESET = "\x1b[0m";
+    const render = () => {
+        const lines = [];
+        lines.push("Select profile (up/down, Enter to apply, q to exit)");
+        lines.push(formatRow(headerName, headerType, headerNote));
+        lines.push(formatRow("-".repeat(nameWidth), "-".repeat(typeWidth), "-".repeat(noteWidth)));
+        for (let i = 0; i < displayRows.length; i++) {
+            const row = displayRows[i];
+            const isActive = activeKeys.has(row.key);
+            const line = ` ${formatRow(row.displayName, row.type, row.noteText)}`;
+            if (i === index) {
+                const prefix = isActive ? `${ANSI_INVERT}${ANSI_GREEN}` : ANSI_INVERT;
+                lines.push(`${prefix}${line}${ANSI_RESET}`);
+            }
+            else {
+                if (isActive) {
+                    lines.push(`${ANSI_GREEN}${line}${ANSI_RESET}`);
+                }
+                else {
+                    lines.push(line);
+                }
+            }
+        }
+        process.stderr.write(`${ANSI_CLEAR}${ANSI_HIDE_CURSOR}${lines.join("\n")}\n`);
+    };
+    return await new Promise((resolve) => {
+        readline.emitKeypressEvents(process.stdin);
+        const stdin = process.stdin;
+        const wasRaw = !!stdin.isRaw;
+        stdin.setRawMode(true);
+        stdin.resume();
+        const cleanup = () => {
+            stdin.removeListener("keypress", onKeypress);
+            if (!wasRaw)
+                stdin.setRawMode(false);
+            stdin.pause();
+            process.stderr.write(`${ANSI_RESET}${ANSI_SHOW_CURSOR}`);
+        };
+        const finish = () => {
+            cleanup();
+            resolve();
+        };
+        const onKeypress = (str, key) => {
+            if (key && key.ctrl && key.name === "c") {
+                finish();
+                return;
+            }
+            if (key && key.name === "up") {
+                index = (index - 1 + displayRows.length) % displayRows.length;
+                render();
+                return;
+            }
+            if (key && key.name === "down") {
+                index = (index + 1) % displayRows.length;
+                render();
+                return;
+            }
+            if (key && key.name === "home") {
+                index = 0;
+                render();
+                return;
+            }
+            if (key && key.name === "end") {
+                index = displayRows.length - 1;
+                render();
+                return;
+            }
+            if (key && (key.name === "return" || key.name === "enter")) {
+                const selectedKey = displayRows[index].key;
+                const selectedType = keyToType.get(selectedKey) || null;
+                if (selectedType) {
+                    for (const activeKey of Array.from(activeKeys)) {
+                        if (keyToType.get(activeKey) === selectedType) {
+                            activeKeys.delete(activeKey);
+                        }
+                    }
+                }
+                activeKeys.add(selectedKey);
+                printUse(config, selectedKey, null);
+                render();
+                return;
+            }
+            if (key && key.name === "escape") {
+                finish();
+                return;
+            }
+            if (str === "q" || str === "Q") {
+                finish();
+            }
+        };
+        stdin.on("keypress", onKeypress);
+        render();
+    });
+}

package/bin/ui/readline.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReadline = createReadline;
+exports.ask = ask;
+exports.askRequired = askRequired;
+exports.askConfirm = askConfirm;
+exports.askType = askType;
+exports.askProfileName = askProfileName;
+/**
+ * Readline utilities
+ */
+const readline = require("readline");
+const match_1 = require("../profile/match");
+function createReadline() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+function ask(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer));
+    });
+}
+async function askRequired(rl, question) {
+    while (true) {
+        const answer = String(await ask(rl, question)).trim();
+        if (answer)
+            return answer;
+    }
+}
+async function askConfirm(rl, question) {
+    const answer = String(await ask(rl, question)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+}
+async function askType(rl) {
+    while (true) {
+        const answer = String(await ask(rl, "Select type (1=codex, 2=claude): "))
+            .trim()
+            .toLowerCase();
+        if (answer === "1")
+            return "codex";
+        if (answer === "2")
+            return "claude";
+        const normalized = answer.replace(/[\s-]+/g, "");
+        if (normalized === "codex")
+            return "codex";
+        if (normalized === "claude" ||
+            normalized === "claudecode" ||
+            normalized === "cc")
+            return "claude";
+    }
+}
+async function askProfileName(rl, config, defaultName, type) {
+    while (true) {
+        const answer = String(await ask(rl, `Profile name (default: ${defaultName}): `)).trim();
+        const baseName = answer || defaultName;
+        if (!baseName)
+            continue;
+        const matches = (0, match_1.findProfileKeysByName)(config, baseName, type);
+        if (matches.length === 0) {
+            return { name: baseName, key: null };
+        }
+        if (matches.length === 1) {
+            const overwrite = String(await ask(rl, `Profile "${baseName}" exists. Overwrite? (y/N): `))
+                .trim()
+                .toLowerCase();
+            if (overwrite === "y" || overwrite === "yes") {
+                return { name: baseName, key: matches[0] };
+            }
+            continue;
+        }
+        console.log(`Multiple profiles named "${baseName}" for type "${type}". ` +
+            `Use a unique name or update by key in config.`);
+    }
+}