@praeviso/code-env-switch 0.1.0 → 0.1.2

package/bin/statusline/index.js

@@ -0,0 +1,469 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStatuslineResult = buildStatuslineResult;
+/**
+ * Statusline builder
+ */
+const fs = require("fs");
+const path = require("path");
+const child_process_1 = require("child_process");
+const constants_1 = require("../constants");
+const type_1 = require("../profile/type");
+const usage_1 = require("../usage");
+const COLOR_ENABLED = !process.env.NO_COLOR && process.env.TERM !== "dumb";
+const ANSI_RESET = "\x1b[0m";
+const ICON_GIT = "⎇";
+const ICON_PROFILE = "👤";
+const ICON_MODEL = "⚙";
+const ICON_USAGE = "⚡";
+const ICON_CONTEXT = "🧠";
+const ICON_REVIEW = "📝";
+const ICON_CWD = "📁";
+function colorize(text, colorCode) {
+    if (!COLOR_ENABLED)
+        return text;
+    return `\x1b[${colorCode}m${text}${ANSI_RESET}`;
+}
+function dim(text) {
+    return colorize(text, "2");
+}
+function getCwdSegment(cwd) {
+    if (!cwd)
+        return null;
+    const base = path.basename(cwd) || cwd;
+    const segment = `${ICON_CWD} ${base}`;
+    return dim(segment);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStdinJson() {
+    if (process.stdin.isTTY)
+        return null;
+    try {
+        const raw = fs.readFileSync(0, "utf8");
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return null;
+        const parsed = JSON.parse(trimmed);
+        if (!isRecord(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function firstNonEmpty(...values) {
+    for (const value of values) {
+        if (value === null || value === undefined)
+            continue;
+        const text = String(value).trim();
+        if (text)
+            return text;
+    }
+    return null;
+}
+function coerceNumber(value) {
+    if (value === null || value === undefined || value === "")
+        return null;
+    const num = Number(value);
+    if (!Number.isFinite(num))
+        return null;
+    return num;
+}
+function firstNumber(...values) {
+    for (const value of values) {
+        const num = coerceNumber(value);
+        if (num !== null)
+            return num;
+    }
+    return null;
+}
+function normalizeTypeValue(value) {
+    if (!value)
+        return null;
+    const normalized = (0, type_1.normalizeType)(value);
+    if (normalized)
+        return normalized;
+    const trimmed = String(value).trim();
+    return trimmed ? trimmed : null;
+}
+function detectTypeFromEnv() {
+    const matches = constants_1.DEFAULT_PROFILE_TYPES.filter((type) => {
+        const suffix = type.toUpperCase();
+        return (process.env[`CODE_ENV_PROFILE_KEY_${suffix}`] ||
+            process.env[`CODE_ENV_PROFILE_NAME_${suffix}`]);
+    });
+    if (matches.length === 1)
+        return matches[0];
+    return null;
+}
+function resolveEnvProfile(type) {
+    const genericKey = process.env.CODE_ENV_PROFILE_KEY || null;
+    const genericName = process.env.CODE_ENV_PROFILE_NAME || null;
+    if (!type) {
+        return { key: genericKey, name: genericName };
+    }
+    const suffix = type.toUpperCase();
+    const key = process.env[`CODE_ENV_PROFILE_KEY_${suffix}`] || genericKey;
+    const name = process.env[`CODE_ENV_PROFILE_NAME_${suffix}`] || genericName;
+    return { key: key || null, name: name || null };
+}
+function getModelFromInput(input) {
+    if (!input)
+        return null;
+    const raw = input.model;
+    if (!raw)
+        return null;
+    if (typeof raw === "string")
+        return raw;
+    if (isRecord(raw)) {
+        const displayName = raw.displayName || raw.display_name;
+        if (displayName)
+            return String(displayName);
+        if (raw.id)
+            return String(raw.id);
+    }
+    return null;
+}
+function getModelProviderFromInput(input) {
+    if (!input || !input.model_provider)
+        return null;
+    const provider = String(input.model_provider).trim();
+    return provider ? provider : null;
+}
+function getInputProfile(input) {
+    if (!input || !isRecord(input.profile))
+        return null;
+    return input.profile;
+}
+function getInputUsage(input) {
+    var _a, _b, _c, _d;
+    if (!input)
+        return null;
+    if (isRecord(input.usage)) {
+        return input.usage;
+    }
+    const tokenUsage = input.token_usage;
+    if (tokenUsage === null || tokenUsage === undefined)
+        return null;
+    if (typeof tokenUsage === "number") {
+        return {
+            todayTokens: null,
+            totalTokens: coerceNumber(tokenUsage),
+            inputTokens: null,
+            outputTokens: null,
+        };
+    }
+    if (isRecord(tokenUsage)) {
+        const record = tokenUsage;
+        return {
+            todayTokens: (_a = firstNumber(record.todayTokens, record.today, record.today_tokens, record.daily, record.daily_tokens)) !== null && _a !== void 0 ? _a : null,
+            totalTokens: (_b = firstNumber(record.totalTokens, record.total, record.total_tokens)) !== null && _b !== void 0 ? _b : null,
+            inputTokens: (_c = firstNumber(record.inputTokens, record.input, record.input_tokens)) !== null && _c !== void 0 ? _c : null,
+            outputTokens: (_d = firstNumber(record.outputTokens, record.output, record.output_tokens)) !== null && _d !== void 0 ? _d : null,
+        };
+    }
+    return null;
+}
+function getContextUsedTokens(input) {
+    if (!input)
+        return null;
+    return coerceNumber(input.context_window_used_tokens);
+}
+function getContextLeftPercent(input, type) {
+    if (!input)
+        return null;
+    const raw = coerceNumber(input.context_window_percent);
+    if (raw === null || raw < 0)
+        return null;
+    const percent = raw <= 1 ? raw * 100 : raw;
+    if (percent > 100)
+        return null;
+    const usedTokens = getContextUsedTokens(input);
+    const normalizedType = normalizeTypeValue(type);
+    // Prefer treating the percent as "remaining" for codex/claude and when usage is absent.
+    const preferRemaining = normalizedType === "codex" ||
+        normalizedType === "claude" ||
+        usedTokens === null ||
+        (usedTokens <= 0 && percent >= 99);
+    const left = preferRemaining ? percent : 100 - percent;
+    return Math.max(0, Math.min(100, left));
+}
+function getWorkspaceDir(input) {
+    if (!input || !isRecord(input.workspace))
+        return null;
+    const currentDir = input.workspace.current_dir;
+    if (currentDir) {
+        const trimmed = String(currentDir).trim();
+        if (trimmed)
+            return trimmed;
+    }
+    const projectDir = input.workspace.project_dir;
+    if (!projectDir)
+        return null;
+    const trimmed = String(projectDir).trim();
+    return trimmed ? trimmed : null;
+}
+function getGitStatusFromInput(input) {
+    if (!input || !input.git_branch)
+        return null;
+    const branch = String(input.git_branch).trim();
+    if (!branch)
+        return null;
+    return {
+        branch,
+        ahead: 0,
+        behind: 0,
+        staged: 0,
+        unstaged: 0,
+        untracked: 0,
+        conflicted: 0,
+    };
+}
+function getGitStatus(cwd) {
+    if (!cwd)
+        return null;
+    const result = (0, child_process_1.spawnSync)("git", ["-C", cwd, "status", "--porcelain=v2", "-b"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (result.status !== 0 || !result.stdout)
+        return null;
+    const status = {
+        branch: null,
+        ahead: 0,
+        behind: 0,
+        staged: 0,
+        unstaged: 0,
+        untracked: 0,
+        conflicted: 0,
+    };
+    const lines = result.stdout.split(/\r?\n/);
+    for (const line of lines) {
+        if (!line)
+            continue;
+        if (line.startsWith("# branch.head ")) {
+            status.branch = line.slice("# branch.head ".length).trim();
+            continue;
+        }
+        if (line.startsWith("# branch.ab ")) {
+            const parts = line
+                .slice("# branch.ab ".length)
+                .trim()
+                .split(/\s+/);
+            for (const part of parts) {
+                if (part.startsWith("+"))
+                    status.ahead = Number(part.slice(1)) || 0;
+                if (part.startsWith("-"))
+                    status.behind = Number(part.slice(1)) || 0;
+            }
+            continue;
+        }
+        if (line.startsWith("? ")) {
+            status.untracked += 1;
+            continue;
+        }
+        if (line.startsWith("u ")) {
+            status.conflicted += 1;
+            continue;
+        }
+        if (line.startsWith("1 ") || line.startsWith("2 ")) {
+            const parts = line.split(/\s+/);
+            const xy = parts[1] || "";
+            const staged = xy[0];
+            const unstaged = xy[1];
+            if (staged && staged !== ".")
+                status.staged += 1;
+            if (unstaged && unstaged !== ".")
+                status.unstaged += 1;
+            continue;
+        }
+    }
+    if (!status.branch) {
+        status.branch = "HEAD";
+    }
+    return status;
+}
+function formatGitSegment(status) {
+    if (!status || !status.branch)
+        return null;
+    const meta = [];
+    const dirtyCount = status.staged + status.unstaged + status.untracked;
+    if (status.ahead > 0)
+        meta.push(`↑${status.ahead}`);
+    if (status.behind > 0)
+        meta.push(`↓${status.behind}`);
+    if (status.conflicted > 0)
+        meta.push(`✖${status.conflicted}`);
+    if (dirtyCount > 0)
+        meta.push(`+${dirtyCount}`);
+    const suffix = meta.length > 0 ? ` [${meta.join("")}]` : "";
+    const text = `${ICON_GIT} ${status.branch}${suffix}`;
+    const hasConflicts = status.conflicted > 0;
+    const isDirty = dirtyCount > 0;
+    if (hasConflicts)
+        return colorize(text, "31");
+    if (isDirty)
+        return colorize(text, "33");
+    if (status.ahead > 0 || status.behind > 0)
+        return colorize(text, "36");
+    return colorize(text, "32");
+}
+function resolveUsageFromRecords(config, configPath, type, profileKey, profileName, syncUsage) {
+    try {
+        const normalized = (0, type_1.normalizeType)(type || "");
+        if (!normalized || (!profileKey && !profileName))
+            return null;
+        const totals = (0, usage_1.readUsageTotalsIndex)(config, configPath, syncUsage);
+        if (!totals)
+            return null;
+        const usage = (0, usage_1.resolveUsageTotalsForProfile)(totals, normalized, profileKey, profileName);
+        if (!usage)
+            return null;
+        return {
+            todayTokens: usage.today,
+            totalTokens: usage.total,
+            inputTokens: null,
+            outputTokens: null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function formatUsageSegment(usage) {
+    var _a;
+    if (!usage)
+        return null;
+    const today = (_a = usage.todayTokens) !== null && _a !== void 0 ? _a : (usage.inputTokens !== null || usage.outputTokens !== null
+        ? (usage.inputTokens || 0) + (usage.outputTokens || 0)
+        : usage.totalTokens);
+    if (today === null)
+        return null;
+    const text = `Today ${(0, usage_1.formatTokenCount)(today)}`;
+    return colorize(`${ICON_USAGE} ${text}`, "33");
+}
+function formatModelSegment(model, provider) {
+    if (!model)
+        return null;
+    const providerLabel = provider ? `${provider}:${model}` : model;
+    return colorize(`${ICON_MODEL} ${providerLabel}`, "35");
+}
+function formatProfileSegment(type, profileKey, profileName) {
+    const name = profileName || profileKey;
+    if (!name)
+        return null;
+    const label = type ? `${type}:${name}` : name;
+    return colorize(`${ICON_PROFILE} ${label}`, "37");
+}
+function formatContextSegment(contextLeft) {
+    if (contextLeft === null)
+        return null;
+    const left = Math.max(0, Math.min(100, Math.round(contextLeft)));
+    return colorize(`${ICON_CONTEXT} ${left}% left`, "36");
+}
+function formatContextUsedSegment(usedTokens) {
+    if (usedTokens === null)
+        return null;
+    return colorize(`${ICON_CONTEXT} ${(0, usage_1.formatTokenCount)(usedTokens)} used`, "36");
+}
+function formatModeSegment(reviewMode) {
+    if (!reviewMode)
+        return null;
+    return colorize(`${ICON_REVIEW} review`, "34");
+}
+function buildStatuslineResult(args, config, configPath) {
+    const stdinInput = readStdinJson();
+    const inputProfile = getInputProfile(stdinInput);
+    let typeCandidate = firstNonEmpty(args.type, process.env.CODE_ENV_TYPE, inputProfile ? inputProfile.type : null, stdinInput ? stdinInput.type : null);
+    if (!typeCandidate) {
+        typeCandidate = detectTypeFromEnv();
+    }
+    let type = normalizeTypeValue(typeCandidate);
+    const envProfile = resolveEnvProfile(type);
+    let profileKey = firstNonEmpty(args.profileKey, envProfile.key, inputProfile ? inputProfile.key : null);
+    let profileName = firstNonEmpty(args.profileName, envProfile.name, inputProfile ? inputProfile.name : null);
+    if (profileKey && !profileName && config.profiles && config.profiles[profileKey]) {
+        const profile = config.profiles[profileKey];
+        profileName = (0, type_1.getProfileDisplayName)(profileKey, profile, type || undefined);
+        if (!type) {
+            const inferred = (0, type_1.inferProfileType)(profileKey, profile, null);
+            if (inferred)
+                type = inferred;
+        }
+    }
+    if (!type && profileKey && config.profiles && config.profiles[profileKey]) {
+        const profile = config.profiles[profileKey];
+        const inferred = (0, type_1.inferProfileType)(profileKey, profile, null);
+        if (inferred)
+            type = inferred;
+    }
+    const cwd = firstNonEmpty(args.cwd, process.env.CODE_ENV_CWD, getWorkspaceDir(stdinInput), stdinInput ? stdinInput.cwd : null, process.cwd());
+    const model = firstNonEmpty(args.model, process.env.CODE_ENV_MODEL, getModelFromInput(stdinInput));
+    const modelProvider = firstNonEmpty(process.env.CODE_ENV_MODEL_PROVIDER, getModelProviderFromInput(stdinInput));
+    const usage = {
+        todayTokens: firstNumber(args.usageToday, process.env.CODE_ENV_USAGE_TODAY),
+        totalTokens: firstNumber(args.usageTotal, process.env.CODE_ENV_USAGE_TOTAL),
+        inputTokens: firstNumber(args.usageInput, process.env.CODE_ENV_USAGE_INPUT),
+        outputTokens: firstNumber(args.usageOutput, process.env.CODE_ENV_USAGE_OUTPUT),
+    };
+    const hasExplicitUsage = usage.todayTokens !== null ||
+        usage.totalTokens !== null ||
+        usage.inputTokens !== null ||
+        usage.outputTokens !== null;
+    let finalUsage = hasExplicitUsage ? usage : null;
+    if (!finalUsage) {
+        finalUsage = resolveUsageFromRecords(config, configPath, type, profileKey, profileName, args.syncUsage);
+    }
+    let gitStatus = getGitStatus(cwd);
+    if (!gitStatus) {
+        gitStatus = getGitStatusFromInput(stdinInput);
+    }
+    else {
+        const inputGit = getGitStatusFromInput(stdinInput);
+        if (inputGit && (!gitStatus.branch || gitStatus.branch === "HEAD")) {
+            gitStatus.branch = inputGit.branch;
+        }
+    }
+    const gitSegment = formatGitSegment(gitStatus);
+    const profileSegment = formatProfileSegment(type, profileKey, profileName);
+    const modelSegment = formatModelSegment(model, modelProvider);
+    const usageSegment = formatUsageSegment(finalUsage);
+    const contextLeft = getContextLeftPercent(stdinInput, type);
+    const contextSegment = formatContextSegment(contextLeft);
+    const contextUsedTokens = getContextUsedTokens(stdinInput);
+    const contextUsedSegment = contextSegment === null ? formatContextUsedSegment(contextUsedTokens) : null;
+    const modeSegment = formatModeSegment((stdinInput === null || stdinInput === void 0 ? void 0 : stdinInput.review_mode) === true);
+    const cwdSegment = getCwdSegment(cwd);
+    const segments = [];
+    if (gitSegment)
+        segments.push(gitSegment);
+    if (profileSegment)
+        segments.push(profileSegment);
+    if (modeSegment)
+        segments.push(modeSegment);
+    if (modelSegment)
+        segments.push(modelSegment);
+    if (usageSegment)
+        segments.push(usageSegment);
+    if (contextSegment)
+        segments.push(contextSegment);
+    if (contextUsedSegment)
+        segments.push(contextUsedSegment);
+    if (cwdSegment)
+        segments.push(cwdSegment);
+    const text = segments.join(" ");
+    return {
+        text,
+        json: {
+            cwd,
+            type,
+            profile: { key: profileKey, name: profileName },
+            model,
+            usage: finalUsage,
+            git: gitStatus,
+        },
+    };
+}

package/bin/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for codenv
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/ui/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInteractiveUse = exports.runInteractiveAdd = exports.askProfileName = exports.askType = exports.askConfirm = exports.askRequired = exports.ask = exports.createReadline = void 0;
+/**
+ * UI module exports
+ */
+var readline_1 = require("./readline");
+Object.defineProperty(exports, "createReadline", { enumerable: true, get: function () { return readline_1.createReadline; } });
+Object.defineProperty(exports, "ask", { enumerable: true, get: function () { return readline_1.ask; } });
+Object.defineProperty(exports, "askRequired", { enumerable: true, get: function () { return readline_1.askRequired; } });
+Object.defineProperty(exports, "askConfirm", { enumerable: true, get: function () { return readline_1.askConfirm; } });
+Object.defineProperty(exports, "askType", { enumerable: true, get: function () { return readline_1.askType; } });
+Object.defineProperty(exports, "askProfileName", { enumerable: true, get: function () { return readline_1.askProfileName; } });
+var interactive_1 = require("./interactive");
+Object.defineProperty(exports, "runInteractiveAdd", { enumerable: true, get: function () { return interactive_1.runInteractiveAdd; } });
+Object.defineProperty(exports, "runInteractiveUse", { enumerable: true, get: function () { return interactive_1.runInteractiveUse; } });

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();
+    });
+}