opencode-openai-account-switcher 0.1.0

package/dist/ui/menu.js

@@ -0,0 +1,305 @@
+import { ANSI } from "./ansi.js";
+import { select } from "./select.js";
+import { confirm } from "./confirm.js";
+function defaultMenuCapabilities() {
+    return {
+        importAuth: false,
+        quota: true,
+        refreshIdentity: false,
+        checkModels: false,
+        defaultAccountGroup: false,
+        assignModels: false,
+        experimentalSlashCommands: true,
+        networkRetry: true,
+        syntheticAgentInitiator: false,
+    };
+}
+export function getMenuCopy(language = "zh", provider = "codex") {
+    void provider;
+    if (language === "en") {
+        return {
+            menuTitle: "OpenAI Codex accounts",
+            menuSubtitle: "Select an action or account",
+            switchLanguageLabel: "切换到中文",
+            actionsHeading: "Actions",
+            commonSettingsHeading: "Common settings",
+            providerSettingsHeading: "Provider settings",
+            addAccount: "Add account",
+            addAccountHint: "OpenAI OAuth login",
+            importAuth: "Import from auth.json",
+            checkQuotas: "Refresh snapshots",
+            refreshIdentity: "Sync account identity",
+            checkModels: "Sync available models",
+            defaultAccountGroup: "Default account group",
+            assignModels: "Assign account groups per model",
+            autoRefreshOn: "Auto refresh: On",
+            autoRefreshOff: "Auto refresh: Off",
+            setRefresh: "Set refresh interval",
+            experimentalSlashCommandsOn: "Experimental slash commands: On",
+            experimentalSlashCommandsOff: "Experimental slash commands: Off",
+            experimentalSlashCommandsHint: "Experimental provider-specific slash commands",
+            retryOn: "Network Retry: On",
+            retryOff: "Network Retry: Off",
+            retryHint: "Helps recover some requests after retries or malformed responses",
+            syntheticInitiatorOn: "Send synthetic messages as agent: On",
+            syntheticInitiatorOff: "Send synthetic messages as agent: Off",
+            syntheticInitiatorHint: "Changes upstream behavior; misuse may increase billing risk or trigger abuse signals",
+            accountsHeading: "Accounts",
+            dangerHeading: "Danger zone",
+            removeAll: "Remove all accounts",
+        };
+    }
+    return {
+        menuTitle: "OpenAI Codex 账号",
+        menuSubtitle: "请选择操作或账号",
+        switchLanguageLabel: "Switch to English",
+        actionsHeading: "操作",
+        commonSettingsHeading: "通用设置",
+        providerSettingsHeading: "Provider 专属设置",
+        addAccount: "添加账号",
+        addAccountHint: "OpenAI OAuth 登录",
+        importAuth: "从 auth.json 导入",
+        checkQuotas: "刷新快照",
+        refreshIdentity: "同步账号身份信息",
+        checkModels: "同步可用模型列表",
+        defaultAccountGroup: "配置默认账号组",
+        assignModels: "为模型配置账号组",
+        autoRefreshOn: "自动刷新：已开启",
+        autoRefreshOff: "自动刷新：已关闭",
+        setRefresh: "设置刷新间隔",
+        experimentalSlashCommandsOn: "实验性 Slash Commands：已开启",
+        experimentalSlashCommandsOff: "实验性 Slash Commands：已关闭",
+        experimentalSlashCommandsHint: "当前 provider 的实验性 Slash Commands 开关",
+        retryOn: "Network Retry：已开启",
+        retryOff: "Network Retry：已关闭",
+        retryHint: "请求异常时可自动重试并修复部分请求",
+        syntheticInitiatorOn: "synthetic 消息按 agent 身份发送：已开启",
+        syntheticInitiatorOff: "synthetic 消息按 agent 身份发送：已关闭",
+        syntheticInitiatorHint: "会改变与 upstream 的默认行为；误用可能带来异常计费或 abuse 风险",
+        accountsHeading: "账号",
+        dangerHeading: "危险操作",
+        removeAll: "删除全部账号",
+    };
+}
+function formatRelativeTime(timestamp) {
+    if (!timestamp)
+        return "never";
+    const days = Math.floor((Date.now() - timestamp) / 86400000);
+    if (days === 0)
+        return "today";
+    if (days === 1)
+        return "yesterday";
+    if (days < 7)
+        return `${days}d ago`;
+    if (days < 30)
+        return `${Math.floor(days / 7)}w ago`;
+    return new Date(timestamp).toLocaleDateString();
+}
+function formatDate(timestamp) {
+    if (!timestamp)
+        return "unknown";
+    return new Date(timestamp).toLocaleDateString();
+}
+function getStatusBadge(status) {
+    if (status === "expired")
+        return `${ANSI.red}[expired]${ANSI.reset}`;
+    return "";
+}
+export function buildMenuItems(input) {
+    const provider = input.provider ?? "codex";
+    const copy = getMenuCopy(input.language, provider);
+    const capabilities = {
+        ...defaultMenuCapabilities(),
+        ...input.capabilities,
+    };
+    const quotaHint = input.lastQuotaRefresh ? `last ${formatRelativeTime(input.lastQuotaRefresh)}` : undefined;
+    const experimentalSlashCommandsEnabled = input.experimentalSlashCommandsEnabled !== false;
+    const providerActions = [
+        { label: copy.actionsHeading, value: { type: "cancel" }, kind: "heading" },
+        { label: copy.switchLanguageLabel, value: { type: "toggle-language" }, color: "cyan" },
+        { label: copy.addAccount, value: { type: "add" }, color: "cyan", hint: copy.addAccountHint },
+    ];
+    if (capabilities.importAuth) {
+        providerActions.push({ label: copy.importAuth, value: { type: "import" }, color: "cyan" });
+    }
+    if (capabilities.quota) {
+        providerActions.push({ label: copy.checkQuotas, value: { type: "quota" }, color: "cyan", hint: quotaHint });
+    }
+    if (capabilities.refreshIdentity) {
+        providerActions.push({ label: copy.refreshIdentity, value: { type: "refresh-identity" }, color: "cyan" });
+    }
+    if (capabilities.checkModels) {
+        providerActions.push({ label: copy.checkModels, value: { type: "check-models" }, color: "cyan" });
+    }
+    if (capabilities.defaultAccountGroup) {
+        providerActions.push({
+            label: copy.defaultAccountGroup,
+            value: { type: "configure-default-group" },
+            color: "cyan",
+            hint: input.defaultAccountGroupCount !== undefined ? `${input.defaultAccountGroupCount} selected` : undefined,
+        });
+    }
+    if (capabilities.assignModels) {
+        providerActions.push({
+            label: copy.assignModels,
+            value: { type: "assign-models" },
+            color: "cyan",
+            hint: input.modelAccountAssignmentCount ? `${input.modelAccountAssignmentCount} groups` : undefined,
+        });
+    }
+    const commonSettings = [
+        { label: copy.commonSettingsHeading, value: { type: "cancel" }, kind: "heading" },
+        {
+            label: experimentalSlashCommandsEnabled ? copy.experimentalSlashCommandsOn : copy.experimentalSlashCommandsOff,
+            value: { type: "toggle-experimental-slash-commands" },
+            color: "cyan",
+            hint: copy.experimentalSlashCommandsHint,
+            disabled: !capabilities.experimentalSlashCommands,
+        },
+        {
+            label: input.networkRetryEnabled ? copy.retryOn : copy.retryOff,
+            value: { type: "toggle-network-retry" },
+            color: "cyan",
+            hint: copy.retryHint,
+            disabled: !capabilities.networkRetry,
+        },
+    ];
+    const providerSettings = [
+        { label: copy.providerSettingsHeading, value: { type: "cancel" }, kind: "heading" },
+    ];
+    providerSettings.push({
+        label: input.refresh?.enabled ? copy.autoRefreshOn : copy.autoRefreshOff,
+        value: { type: "toggle-refresh" },
+        color: "cyan",
+        hint: input.refresh ? `${input.refresh.minutes}m` : undefined,
+    });
+    providerSettings.push({ label: copy.setRefresh, value: { type: "set-interval" }, color: "cyan" });
+    if (capabilities.syntheticAgentInitiator) {
+        providerSettings.push({
+            label: input.syntheticAgentInitiatorEnabled ? copy.syntheticInitiatorOn : copy.syntheticInitiatorOff,
+            value: { type: "toggle-synthetic-agent-initiator" },
+            color: "cyan",
+            hint: copy.syntheticInitiatorHint,
+        });
+    }
+    return [
+        ...providerActions,
+        { label: "", value: { type: "cancel" }, separator: true },
+        ...commonSettings,
+        { label: "", value: { type: "cancel" }, separator: true },
+        ...providerSettings,
+        { label: "", value: { type: "cancel" }, separator: true },
+        { label: copy.accountsHeading, value: { type: "cancel" }, kind: "heading" },
+        ...input.accounts.map((account) => {
+            const statusBadge = getStatusBadge(account.status);
+            const currentBadge = account.isCurrent ? ` ${ANSI.cyan}*${ANSI.reset}` : "";
+            const format = (s) => s?.unlimited ? "∞" : s?.remaining !== undefined && s?.entitlement !== undefined ? `${s.remaining}/${s.entitlement}` : "?";
+            const quotaBadge = account.quota
+                ? ` ${ANSI.dim}[${format(account.quota.premium)}|${format(account.quota.chat)}|${format(account.quota.completions)}]${ANSI.reset}`
+                : "";
+            const numbered = `${account.index + 1}. ${account.name}`;
+            const label = `${numbered}${currentBadge}${statusBadge ? ` ${statusBadge}` : ""}${quotaBadge}`;
+            const detail = [
+                account.workspaceName,
+                account.lastUsed ? formatRelativeTime(account.lastUsed) : undefined,
+                account.plan,
+                account.models ? `${account.models.enabled}/${account.models.enabled + account.models.disabled} mods` : undefined,
+            ]
+                .filter(Boolean)
+                .join(" • ");
+            return {
+                label,
+                hint: detail || undefined,
+                value: { type: "switch", account },
+            };
+        }),
+        { label: "", value: { type: "cancel" }, separator: true },
+        { label: copy.dangerHeading, value: { type: "cancel" }, kind: "heading" },
+        { label: copy.removeAll, value: { type: "remove-all" }, color: "red" },
+    ];
+}
+export async function showMenu(accounts, input = {}) {
+    return showMenuWithDeps(accounts, input);
+}
+export async function showMenuWithDeps(accounts, input = {}, deps = {}) {
+    const selectMenu = deps.select ?? select;
+    const confirmAction = deps.confirm ?? confirm;
+    const showAccountActionMenu = deps.showAccountActions ?? showAccountActions;
+    let currentLanguage = input.language ?? "zh";
+    while (true) {
+        const provider = input.provider ?? "codex";
+        const copy = getMenuCopy(currentLanguage, provider);
+        const items = buildMenuItems({
+            provider,
+            accounts,
+            refresh: input.refresh,
+            lastQuotaRefresh: input.lastQuotaRefresh,
+            modelAccountAssignmentCount: input.modelAccountAssignmentCount,
+            defaultAccountGroupCount: input.defaultAccountGroupCount,
+            networkRetryEnabled: input.networkRetryEnabled === true,
+            syntheticAgentInitiatorEnabled: input.syntheticAgentInitiatorEnabled === true,
+            experimentalSlashCommandsEnabled: input.experimentalSlashCommandsEnabled,
+            capabilities: input.capabilities,
+            language: currentLanguage,
+        });
+        const result = await selectMenu(items, {
+            message: copy.menuTitle,
+            subtitle: copy.menuSubtitle,
+            clearScreen: true,
+        });
+        if (!result)
+            return { type: "cancel" };
+        if (result.type === "toggle-language") {
+            currentLanguage = currentLanguage === "zh" ? "en" : "zh";
+            continue;
+        }
+        if (result.type === "switch") {
+            const next = await showAccountActionMenu(result.account, { provider });
+            if (next === "back")
+                continue;
+            return { type: next, account: result.account };
+        }
+        if (result.type === "remove-all") {
+            const ok = await confirmAction("Remove ALL accounts? This cannot be undone.");
+            if (!ok)
+                continue;
+        }
+        return result;
+    }
+}
+export function buildAccountActionItems(account, input = {}) {
+    void account;
+    void input;
+    return [
+        { label: "Back", value: "back" },
+        { label: "Switch to this account", value: "switch", color: "cyan" },
+        { label: "Remove this account", value: "remove", color: "red" },
+    ];
+}
+export async function showAccountActions(account, input = {}) {
+    void input;
+    const badge = getStatusBadge(account.status);
+    const header = `${account.name}${badge ? " " + badge : ""}`;
+    const info = [
+        `Added: ${formatDate(account.addedAt)} | Last used: ${formatRelativeTime(account.lastUsed)}`,
+        account.plan ? `Plan: ${account.plan}` : undefined,
+        account.sku ? `SKU: ${account.sku}` : undefined,
+        account.reset ? `Reset: ${account.reset}` : undefined,
+        account.orgs?.length ? `Orgs: ${account.orgs.slice(0, 2).join(",")}` : undefined,
+    ]
+        .filter(Boolean)
+        .join("\n");
+    const subtitle = info;
+    while (true) {
+        const result = await select(buildAccountActionItems(account), { message: header, subtitle, clearScreen: true, autoSelectSingle: false });
+        if (result === "models") {
+            continue;
+        }
+        if (result === "remove") {
+            const ok = await confirm(`Remove ${account.name}?`);
+            if (!ok)
+                continue;
+        }
+        return result ?? "back";
+    }
+}

package/dist/ui/select.d.ts

@@ -0,0 +1,36 @@
+export declare function buildSelectDebugEvent(input: {
+    stage: "key" | "result";
+    parsedKey: string | null;
+    currentValue?: unknown;
+    nextValue?: unknown;
+}): {
+    stage: "key" | "result";
+    parsedKey: string | null;
+    currentActionType: string | null;
+    nextActionType: string | null;
+    actionType: string;
+} | undefined;
+export interface MenuItem<T = string> {
+    label: string;
+    value: T;
+    hint?: string;
+    disabled?: boolean;
+    separator?: boolean;
+    kind?: "heading";
+    color?: "red" | "green" | "yellow" | "cyan";
+}
+export interface SelectOptions {
+    message: string;
+    subtitle?: string;
+    help?: string;
+    clearScreen?: boolean;
+    autoSelectSingle?: boolean;
+}
+export interface SelectManyOptions extends SelectOptions {
+    doneLabel?: string;
+    backLabel?: string;
+    minSelected?: number;
+    initialSelected?: number[];
+}
+export declare function select<T>(items: MenuItem<T>[], options: SelectOptions): Promise<T | null>;
+export declare function selectMany<T>(items: MenuItem<T>[], options: SelectManyOptions): Promise<T[] | null>;

package/dist/ui/select.js

@@ -0,0 +1,350 @@
+import { ANSI, isTTY, parseKey } from "./ansi.js";
+const defaultSelectDebugLogFile = (() => {
+    const tmp = process.env.TEMP || process.env.TMP || "/tmp";
+    return `${tmp}/opencode-codex-store-debug.log`;
+})();
+function shouldLogSuspiciousAction(actionType) {
+    return actionType === "toggle-network-retry";
+}
+function getActionType(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const actionType = value.type;
+    return typeof actionType === "string" ? actionType : undefined;
+}
+export function buildSelectDebugEvent(input) {
+    const currentActionType = getActionType(input.currentValue);
+    const nextActionType = getActionType(input.nextValue);
+    const actionType = nextActionType ?? currentActionType;
+    if (!shouldLogSuspiciousAction(actionType))
+        return undefined;
+    return {
+        stage: input.stage,
+        parsedKey: input.parsedKey,
+        currentActionType: currentActionType ?? null,
+        nextActionType: nextActionType ?? null,
+        actionType,
+    };
+}
+async function logSelectDebug(input) {
+    const event = buildSelectDebugEvent(input);
+    if (!event)
+        return;
+    const filePath = process.env.OPENCODE_CODEX_STORE_DEBUG_FILE || defaultSelectDebugLogFile;
+    try {
+        const { promises: fs } = await import("node:fs");
+        const { dirname } = await import("node:path");
+        await fs.mkdir(dirname(filePath), { recursive: true });
+        await fs.appendFile(filePath, `${JSON.stringify({ kind: "select-action", at: new Date().toISOString(), ...event })}\n`, "utf8");
+    }
+    catch (error) {
+        console.warn("[codex-store-debug] failed to write select debug log", error);
+    }
+}
+const ESCAPE_TIMEOUT_MS = 50;
+const ANSI_REGEX = new RegExp("\\x1b\\[[0-9;]*m", "g");
+const ANSI_LEADING_REGEX = new RegExp("^\\x1b\\[[0-9;]*m");
+function stripAnsi(input) {
+    return input.replace(ANSI_REGEX, "");
+}
+function truncateAnsi(input, maxVisibleChars) {
+    if (maxVisibleChars <= 0)
+        return "";
+    const visible = stripAnsi(input);
+    if (visible.length <= maxVisibleChars)
+        return input;
+    const suffix = maxVisibleChars >= 3 ? "..." : ".".repeat(maxVisibleChars);
+    const keep = Math.max(0, maxVisibleChars - suffix.length);
+    let out = "";
+    let i = 0;
+    let kept = 0;
+    while (i < input.length && kept < keep) {
+        if (input[i] === "\x1b") {
+            const m = input.slice(i).match(ANSI_LEADING_REGEX);
+            if (m) {
+                out += m[0];
+                i += m[0].length;
+                continue;
+            }
+        }
+        out += input[i];
+        i += 1;
+        kept += 1;
+    }
+    if (out.includes("\x1b["))
+        return `${out}${ANSI.reset}${suffix}`;
+    return out + suffix;
+}
+function getColorCode(color) {
+    if (color === "red")
+        return ANSI.red;
+    if (color === "green")
+        return ANSI.green;
+    if (color === "yellow")
+        return ANSI.yellow;
+    if (color === "cyan")
+        return ANSI.cyan;
+    return "";
+}
+export async function select(items, options) {
+    if (!isTTY())
+        throw new Error("Interactive select requires a TTY terminal");
+    if (items.length === 0)
+        throw new Error("No menu items provided");
+    const isSelectable = (i) => !i.disabled && !i.separator && i.kind !== "heading";
+    const enabled = items.filter(isSelectable);
+    if (enabled.length === 0)
+        throw new Error("All items disabled");
+    const autoSelectSingle = options.autoSelectSingle ?? true;
+    if (enabled.length === 1 && autoSelectSingle)
+        return enabled[0]?.value ?? null;
+    const { message, subtitle } = options;
+    const { stdin, stdout } = process;
+    let cursor = items.findIndex(isSelectable);
+    if (cursor === -1)
+        cursor = 0;
+    let escapeTimeout = null;
+    let done = false;
+    let rendered = 0;
+    const render = () => {
+        const columns = stdout.columns ?? 80;
+        const rows = stdout.rows ?? 24;
+        const clearScreen = options.clearScreen === true;
+        const prev = rendered;
+        if (clearScreen) {
+            stdout.write(ANSI.clearScreen + ANSI.moveTo(1, 1));
+        }
+        else if (prev > 0) {
+            stdout.write(ANSI.up(prev));
+        }
+        let lines = 0;
+        const write = (line) => {
+            stdout.write(`${ANSI.clearLine}${line}\n`);
+            lines += 1;
+        };
+        const subtitleLines = subtitle ? subtitle.split("\n").length + 2 : 0;
+        const fixed = 1 + subtitleLines + 2;
+        const maxVisible = Math.max(1, Math.min(items.length, rows - fixed - 1));
+        let windowStart = 0;
+        let windowEnd = items.length;
+        if (items.length > maxVisible) {
+            windowStart = cursor - Math.floor(maxVisible / 2);
+            windowStart = Math.max(0, Math.min(windowStart, items.length - maxVisible));
+            windowEnd = windowStart + maxVisible;
+        }
+        const visibleItems = items.slice(windowStart, windowEnd);
+        const header = truncateAnsi(message, Math.max(1, columns - 4));
+        write(`${ANSI.dim}┌  ${ANSI.reset}${header}`);
+        if (subtitle) {
+            write(`${ANSI.dim}│${ANSI.reset}`);
+            for (const line of subtitle.split("\n")) {
+                const sub = truncateAnsi(line, Math.max(1, columns - 4));
+                write(`${ANSI.cyan}◆${ANSI.reset}  ${sub}`);
+            }
+            write("");
+        }
+        for (let i = 0; i < visibleItems.length; i += 1) {
+            const index = windowStart + i;
+            const item = visibleItems[i];
+            if (!item)
+                continue;
+            if (item.separator) {
+                write(`${ANSI.dim}│${ANSI.reset}`);
+                continue;
+            }
+            if (item.kind === "heading") {
+                const heading = truncateAnsi(`${ANSI.dim}${ANSI.bold}${item.label}${ANSI.reset}`, Math.max(1, columns - 6));
+                write(`${ANSI.cyan}│${ANSI.reset}  ${heading}`);
+                continue;
+            }
+            const selected = index === cursor;
+            const color = getColorCode(item.color);
+            let label;
+            if (item.disabled) {
+                label = `${ANSI.dim}${item.label} (unavailable)${ANSI.reset}`;
+            }
+            else if (selected) {
+                label = color ? `${color}${item.label}${ANSI.reset}` : item.label;
+                if (item.hint)
+                    label += ` ${ANSI.dim}${item.hint}${ANSI.reset}`;
+            }
+            else {
+                label = color ? `${ANSI.dim}${color}${item.label}${ANSI.reset}` : `${ANSI.dim}${item.label}${ANSI.reset}`;
+                if (item.hint)
+                    label += ` ${ANSI.dim}${item.hint}${ANSI.reset}`;
+            }
+            label = truncateAnsi(label, Math.max(1, columns - 8));
+            if (selected) {
+                write(`${ANSI.cyan}│${ANSI.reset}  ${ANSI.green}●${ANSI.reset} ${label}`);
+            }
+            else {
+                write(`${ANSI.cyan}│${ANSI.reset}  ${ANSI.dim}○${ANSI.reset} ${label}`);
+            }
+        }
+        const windowHint = items.length > visibleItems.length ? ` (${windowStart + 1}-${windowEnd}/${items.length})` : "";
+        const helpText = options.help ?? `Up/Down to select | Enter: confirm | Esc: back${windowHint}`;
+        const help = truncateAnsi(helpText, Math.max(1, columns - 6));
+        write(`${ANSI.cyan}│${ANSI.reset}  ${ANSI.dim}${help}${ANSI.reset}`);
+        write(`${ANSI.cyan}└${ANSI.reset}`);
+        if (!clearScreen && prev > lines) {
+            const extra = prev - lines;
+            for (let i = 0; i < extra; i += 1)
+                write("");
+        }
+        rendered = lines;
+    };
+    return new Promise((resolve) => {
+        const wasRaw = stdin.isRaw ?? false;
+        const cleanup = () => {
+            if (done)
+                return;
+            done = true;
+            if (escapeTimeout) {
+                clearTimeout(escapeTimeout);
+                escapeTimeout = null;
+            }
+            try {
+                stdin.removeListener("data", onKey);
+                stdin.setRawMode(wasRaw);
+                stdin.pause();
+                stdout.write(ANSI.show);
+            }
+            catch { }
+            process.removeListener("SIGINT", onSignal);
+            process.removeListener("SIGTERM", onSignal);
+        };
+        const onSignal = () => {
+            cleanup();
+            resolve(null);
+        };
+        const finish = (value) => {
+            cleanup();
+            resolve(value);
+        };
+        const findNextSelectable = (from, direction) => {
+            if (items.length === 0)
+                return from;
+            let next = from;
+            do {
+                next = (next + direction + items.length) % items.length;
+            } while (items[next]?.disabled || items[next]?.separator || items[next]?.kind === "heading");
+            return next;
+        };
+        const onKey = (data) => {
+            if (escapeTimeout) {
+                clearTimeout(escapeTimeout);
+                escapeTimeout = null;
+            }
+            const action = parseKey(data);
+            if (action === "up") {
+                void logSelectDebug({ stage: "key", parsedKey: action, currentValue: items[cursor]?.value });
+                cursor = findNextSelectable(cursor, -1);
+                render();
+                return;
+            }
+            if (action === "down") {
+                void logSelectDebug({ stage: "key", parsedKey: action, currentValue: items[cursor]?.value });
+                cursor = findNextSelectable(cursor, 1);
+                render();
+                return;
+            }
+            if (action === "enter") {
+                void logSelectDebug({
+                    stage: "key",
+                    parsedKey: action,
+                    currentValue: items[cursor]?.value,
+                });
+                void logSelectDebug({
+                    stage: "result",
+                    parsedKey: action,
+                    currentValue: items[cursor]?.value,
+                    nextValue: items[cursor]?.value,
+                });
+                finish(items[cursor]?.value ?? null);
+                return;
+            }
+            if (action === "escape") {
+                finish(null);
+                return;
+            }
+            if (action === "escape-start") {
+                escapeTimeout = setTimeout(() => {
+                    finish(null);
+                }, ESCAPE_TIMEOUT_MS);
+                return;
+            }
+        };
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            cleanup();
+            resolve(null);
+            return;
+        }
+        stdin.resume();
+        stdout.write(ANSI.hide);
+        render();
+        stdin.on("data", onKey);
+    });
+}
+export async function selectMany(items, options) {
+    const selectable = items
+        .map((item, index) => ({ item, index }))
+        .filter(({ item }) => !item.disabled && !item.separator && item.kind !== "heading");
+    if (selectable.length === 0)
+        return [];
+    const selected = new Set();
+    for (const index of options.initialSelected ?? []) {
+        if (Number.isInteger(index) && index >= 0 && index < selectable.length) {
+            selected.add(index);
+        }
+    }
+    const DONE = "__select_many_done__";
+    const BACK = "__select_many_back__";
+    while (true) {
+        const menuItems = [
+            { label: options.backLabel ?? "Back", value: BACK },
+            {
+                label: options.doneLabel ?? "Done",
+                value: DONE,
+                color: "cyan",
+                hint: `${selected.size} selected`,
+            },
+            { label: "", value: "", separator: true },
+            ...selectable.map(({ item }, index) => {
+                const marker = selected.has(index) ? "[x]" : "[ ]";
+                return {
+                    label: `${marker} ${item.label}`,
+                    value: String(index),
+                    hint: item.hint,
+                    color: item.color,
+                };
+            }),
+        ];
+        const choice = await select(menuItems, {
+            ...options,
+            autoSelectSingle: false,
+            help: options.help ?? "Up/Down to select | Enter: toggle | Choose Done to confirm | Esc: back",
+        });
+        if (choice === null || choice === BACK)
+            return null;
+        if (choice === DONE) {
+            if ((options.minSelected ?? 0) > selected.size)
+                continue;
+            return selectable
+                .map(({ item }, index) => ({ item, index }))
+                .filter(({ index }) => selected.has(index))
+                .map(({ item }) => item.value);
+        }
+        const index = Number(choice);
+        if (!Number.isInteger(index) || index < 0 || index >= selectable.length)
+            continue;
+        if (selected.has(index))
+            selected.delete(index);
+        else
+            selected.add(index);
+    }
+}