termux-dev 1.6.0 → 1.8.0

package/dist/cli/mcp-panel.js

@@ -0,0 +1,432 @@
+import { LiveBlock } from './liveblock.js';
+import { normalizeKey, splitKeys } from './keys.js';
+import { palette } from './ui.js';
+import { displayWidth, padEndWidth, truncateWidth, wrapText } from './width.js';
+import { t } from '../core/i18n.js';
+/** What can be done with a server in its current state, in the order shown. */
+export function actionsFor(status) {
+    if (status.status === 'disabled')
+        return ['enable'];
+    const list = [];
+    if (status.status === 'connected' && status.toolsCount > 0)
+        list.push('tools');
+    list.push('reconnect', 'disable');
+    return list;
+}
+const actionLabel = (a) => t(`mcp.action.${a}`);
+/** The servers in the order of the list: the user's own first, then the project's. */
+export function orderedServers(statuses) {
+    return [...statuses.filter((s) => s.scope !== 'project'), ...statuses.filter((s) => s.scope === 'project')];
+}
+/** How many rows the current screen can focus. */
+export function rowCount(view) {
+    const { screen } = view;
+    const status = (name) => view.statuses.find((s) => s.name === name);
+    switch (screen.kind) {
+        case 'servers':
+            return view.statuses.length;
+        case 'server': {
+            const s = status(screen.name);
+            return s ? actionsFor(s).length : 0;
+        }
+        case 'tools':
+            return status(screen.name)?.toolInfo?.length ?? 0;
+        default:
+            return 0;
+    }
+}
+function statusGlyph(s) {
+    switch (s.status) {
+        case 'connected': return palette.ok('●');
+        case 'connecting': return palette.warn('◌');
+        case 'failed': return palette.err('×');
+        default: return palette.faint('○');
+    }
+}
+function statusText(s) {
+    switch (s.status) {
+        case 'connected': return palette.ok(t('mcp.status.connected'));
+        case 'connecting': return palette.warn(t('mcp.status.connecting'));
+        case 'failed': return palette.err(t('mcp.status.failed'));
+        default: return palette.faint(t('mcp.status.disabled'));
+    }
+}
+function toolTags(tool) {
+    const tags = [];
+    if (tool.readOnly)
+        tags.push(t('mcp.tag.readOnly'));
+    if (tool.destructive)
+        tags.push(t('mcp.tag.destructive'));
+    if (tool.openWorld)
+        tags.push(t('mcp.tag.openWorld'));
+    return tags.join(' · ');
+}
+/** Shows `max` rows of a long list, always including the anchor, with "↑ n more" / "↓ n more" at the cut edges. */
+function windowRows(rows, max, width) {
+    if (rows.length <= max)
+        return rows;
+    const anchor = Math.max(0, rows.findIndex((r) => r.anchor));
+    let start = Math.max(0, Math.min(rows.length - max, anchor - Math.floor(max / 2)));
+    const end = start + max;
+    const out = rows.slice(start, end);
+    const above = start;
+    const below = rows.length - end;
+    const marker = (arrow, n) => ({ text: ' ' + palette.faint(truncateWidth(`${arrow} ${t('mcp.more', { n })}`, width)) });
+    if (above > 0)
+        out[0] = marker('↑', above + 1);
+    if (below > 0)
+        out[out.length - 1] = marker('↓', below + 1);
+    // The anchor must survive the markers.
+    if (!out.some((r) => r.anchor) && rows[anchor])
+        out[Math.min(out.length - 1, Math.max(1, anchor - start))] = rows[anchor];
+    return out;
+}
+function hintsFor(view, width) {
+    if (view.busy)
+        return palette.warn(truncateWidth(t('mcp.status.connecting'), width));
+    const move = ['↑↓', t('settings.keys.move')];
+    const open = ['enter', t('mcp.keys.open')];
+    const back = ['esc', t('mcp.keys.back')];
+    const close = ['esc', t('mcp.keys.close')];
+    const reload = ['r', t('mcp.keys.reload')];
+    const variants = view.screen.kind === 'servers'
+        ? [[move, open, reload, close], [move, open, close], [['↑↓', ''], ['enter', ''], ['esc', '']], [['esc', '']]]
+        : view.screen.kind === 'tool'
+            ? [[back], [['esc', '']]]
+            : [[move, open, back], [['↑↓', ''], ['enter', ''], ['esc', '']], [['esc', '']]];
+    for (const items of variants) {
+        const text = items.map(([k, label]) => palette.text(k) + (label ? ' ' + palette.faint(label) : '')).join(palette.faint(items[0][1] ? ' · ' : ' '));
+        if (displayWidth(text) <= width)
+            return text;
+    }
+    return '';
+}
+function serversBody(view, iw) {
+    const rows = [];
+    const servers = orderedServers(view.statuses);
+    if (servers.length === 0) {
+        rows.push({ text: ' ' + palette.muted(t('mcp.empty')) });
+        for (const line of wrapText(t('mcp.emptyHint'), iw - 3))
+            rows.push({ text: '   ' + palette.faint(line) });
+        return rows;
+    }
+    const nameWidth = Math.min(24, Math.max(8, ...servers.map((s) => displayWidth(s.name))));
+    let scope;
+    servers.forEach((s, i) => {
+        const sc = s.scope === 'project' ? 'project' : 'user';
+        if (sc !== scope) {
+            if (scope !== undefined)
+                rows.push({ text: '' });
+            scope = sc;
+            rows.push({ text: ' ' + palette.faint(t(sc === 'project' ? 'mcp.scope.project' : 'mcp.scope.user')) });
+        }
+        const focused = i === view.focus;
+        const mark = focused ? palette.accent('❯') : ' ';
+        const name = focused ? palette.bold(palette.text(truncateWidth(s.name, nameWidth))) : palette.muted(truncateWidth(s.name, nameWidth));
+        const right = s.status === 'connected' ? palette.muted(t('mcp.toolsCount', { n: s.toolsCount }))
+            : s.status === 'connecting' ? palette.warn(t('mcp.status.connecting'))
+                : s.status === 'failed' ? palette.err(t('mcp.status.failed'))
+                    : palette.faint(t('mcp.status.disabled'));
+        const left = ` ${mark} ${statusGlyph(s)} ${padEndWidth(name, nameWidth)}`;
+        const gap = Math.max(2, iw - displayWidth(left) - displayWidth(right) - 1);
+        rows.push({ text: left + ' '.repeat(gap) + right, shaded: focused, anchor: focused });
+    });
+    return rows;
+}
+function serverBody(view, name, iw) {
+    const s = view.statuses.find((x) => x.name === name);
+    if (!s)
+        return [];
+    const rows = [];
+    const labels = ['status', 'command', 'config', 'capabilities', 'tools', 'error'];
+    const labelW = Math.min(16, Math.max(...labels.map((l) => displayWidth(t(`mcp.detail.${l}`) + ':'))) + 1);
+    const field = (label, value, plainValue) => {
+        const head = ' ' + palette.faint(padEndWidth(t(`mcp.detail.${label}`) + ':', labelW));
+        const room = Math.max(8, iw - 1 - labelW - 1);
+        const lines = wrapText(plainValue, room);
+        rows.push({ text: head + (lines.length <= 1 ? value : lines[0]) });
+        if (lines.length > 1)
+            for (const l of lines.slice(1, 3))
+                rows.push({ text: ' ' + ' '.repeat(labelW) + l });
+    };
+    const connecting = s.status === 'connecting';
+    rows.push({ text: ' ' + palette.faint(padEndWidth(t('mcp.detail.status') + ':', labelW)) + statusGlyph(s) + ' ' + statusText(s) });
+    field('command', palette.muted(truncateWidth(s.command, iw - 1 - labelW - 1)), s.command);
+    if (s.source)
+        field('config', palette.muted(s.source), s.source);
+    if (s.capabilities && s.capabilities.length > 0)
+        field('capabilities', palette.text(s.capabilities.join(' · ')), s.capabilities.join(' · '));
+    if (s.status === 'connected')
+        field('tools', palette.muted(String(s.toolsCount)), String(s.toolsCount));
+    if (s.error) {
+        const lines = wrapText(s.error, Math.max(8, iw - 1 - labelW - 1)).slice(0, 3);
+        rows.push({ text: ' ' + palette.faint(padEndWidth(t('mcp.detail.error') + ':', labelW)) + palette.err(lines[0] ?? '') });
+        for (const l of lines.slice(1))
+            rows.push({ text: ' ' + ' '.repeat(labelW) + palette.err(l) });
+    }
+    rows.push({ text: '' });
+    if (!connecting) {
+        actionsFor(s).forEach((a, i) => {
+            const focused = i === view.focus;
+            const mark = focused ? palette.accent('❯') : ' ';
+            const label = `${i + 1}. ${actionLabel(a)}`;
+            rows.push({ text: ` ${mark} ${focused ? palette.bold(palette.text(label)) : palette.muted(label)}`, shaded: focused, anchor: focused });
+        });
+    }
+    return rows;
+}
+function toolsBody(view, name, iw) {
+    const s = view.statuses.find((x) => x.name === name);
+    const tools = s?.toolInfo ?? [];
+    if (tools.length === 0)
+        return [{ text: ' ' + palette.muted(t('mcp.noTools')) }];
+    const nameWidth = Math.min(Math.floor(iw * 0.6), Math.max(...tools.map((x) => displayWidth(x.name))) + 1);
+    return tools.map((tool, i) => {
+        const focused = i === view.focus;
+        const mark = focused ? palette.accent('❯') : ' ';
+        const left = ` ${mark} ${padEndWidth(focused ? palette.bold(palette.text(truncateWidth(tool.name, nameWidth))) : palette.muted(truncateWidth(tool.name, nameWidth)), nameWidth)}`;
+        const room = iw - displayWidth(left) - 1;
+        const tags = room > 6 ? palette.faint(truncateWidth(toolTags(tool), room)) : '';
+        return { text: left + ' ' + tags, shaded: focused, anchor: focused };
+    });
+}
+function toolBody(view, name, toolName, iw) {
+    const tool = view.statuses.find((x) => x.name === name)?.toolInfo?.find((x) => x.name === toolName);
+    if (!tool)
+        return [];
+    const rows = [];
+    const tags = toolTags(tool);
+    if (tags)
+        rows.push({ text: ' ' + palette.faint(tags) });
+    const desc = tool.description.replace(/\s+/g, ' ').trim();
+    if (desc) {
+        const lines = wrapText(desc, iw - 2);
+        for (const l of lines.slice(0, 6))
+            rows.push({ text: ' ' + palette.text(l) });
+        if (lines.length > 6)
+            rows.push({ text: ' ' + palette.faint('…') });
+    }
+    rows.push({ text: '' });
+    rows.push({ text: ' ' + palette.faint(t('mcp.params')) });
+    if (tool.params.length === 0)
+        rows.push({ text: '   ' + palette.muted(t('mcp.noParams')) });
+    const nameW = Math.min(24, Math.max(4, ...tool.params.map((p) => displayWidth(p.name))));
+    for (const p of tool.params) {
+        const req = p.required ? palette.warn(' ' + t('mcp.required')) : '';
+        const left = '   ' + palette.text(padEndWidth(truncateWidth(p.name, nameW), nameW)) + '  ' + palette.muted(truncateWidth(p.type, 14));
+        rows.push({ text: left + req });
+        const d = p.description.replace(/\s+/g, ' ').trim();
+        if (d)
+            rows.push({ text: '     ' + palette.faint(truncateWidth(d, Math.max(8, iw - 7))) });
+    }
+    return rows;
+}
+function titleFor(view) {
+    const { screen, statuses } = view;
+    const s = 'name' in screen ? statuses.find((x) => x.name === screen.name) : undefined;
+    switch (screen.kind) {
+        case 'servers':
+            return { title: t('mcp.title'), subtitle: t('mcp.count', { n: statuses.length }) };
+        case 'server':
+            return { title: screen.name, subtitle: s ? t(s.scope === 'project' ? 'mcp.scope.project' : 'mcp.scope.user') : '' };
+        case 'tools':
+            return { title: t('mcp.toolsTitle', { name: screen.name }), subtitle: s ? t('mcp.toolsCount', { n: s.toolInfo?.length ?? 0 }) : '' };
+        default:
+            return { title: screen.tool, subtitle: screen.name };
+    }
+}
+/** The whole panel as terminal rows: a framed card, or a plain list on a narrow screen. */
+export function renderMcpPanel(view, cols, termRows = 30) {
+    const compact = cols < 60;
+    const W = compact ? Math.max(20, cols - 1) : Math.min(cols - 1, 76);
+    const iw = compact ? W - 1 : W - 4;
+    const { screen } = view;
+    let body;
+    switch (screen.kind) {
+        case 'servers':
+            body = serversBody(view, iw);
+            break;
+        case 'server':
+            body = serverBody(view, screen.name, iw);
+            break;
+        case 'tools':
+            body = toolsBody(view, screen.name, iw);
+            break;
+        default: body = toolBody(view, screen.name, screen.tool, iw);
+    }
+    // The frame, the blank rows and the hints take 6 rows of the screen; the rest is for the list.
+    const room = Math.max(3, termRows - (compact ? 3 : 6));
+    body = windowRows(body, room, iw);
+    if (body.length > room)
+        body = body.slice(0, room);
+    const { title, subtitle } = titleFor(view);
+    const hints = hintsFor(view, cols - 2);
+    if (compact) {
+        const head = ' ' + palette.bold(palette.accent(truncateWidth(title, W - 2))) + (subtitle ? palette.faint(' · ' + truncateWidth(subtitle, Math.max(4, W - displayWidth(title) - 6))) : '');
+        return [head, ...body.map((r) => (r.shaded ? palette.shade(padEndWidth(r.text, W)) : r.text)), ' ' + hints];
+    }
+    const rule = palette.rule;
+    const box = (content, shaded = false) => rule('│') + (shaded ? palette.shade(' ' + padEndWidth(content, iw) + ' ') : ' ' + padEndWidth(content, iw) + ' ') + rule('│');
+    const titleText = ' ' + palette.bold(palette.accent(truncateWidth(title, W - 14))) + ' ';
+    const subText = subtitle ? ' ' + palette.muted(truncateWidth(subtitle, Math.max(4, W - 8 - displayWidth(titleText)))) + ' ' : '';
+    const fill = Math.max(0, W - 4 - displayWidth(titleText) - displayWidth(subText));
+    return [
+        rule('╭─') + titleText + rule('─'.repeat(fill)) + subText + rule('─╮'),
+        box(''),
+        ...body.map((r) => box(r.text, r.shaded)),
+        box(''),
+        rule('╰' + '─'.repeat(W - 2) + '╯'),
+        ' ' + hints,
+    ];
+}
+/** Shows the panel and resolves when it is closed (Esc on the first screen, q, Ctrl+C). The panel is erased on close. */
+export function runMcpPanel(controller, options = {}) {
+    return new Promise((resolve) => {
+        const { input, output } = options.io ?? { input: process.stdin, output: process.stdout };
+        const block = new LiveBlock(output);
+        let stack = [{ kind: 'servers' }];
+        const focusByScreen = new Map();
+        let busy = false;
+        let closed = false;
+        const screen = () => stack[stack.length - 1];
+        const screenKey = () => JSON.stringify(screen());
+        const view = () => ({ statuses: controller.getStatuses(), screen: screen(), focus: focusByScreen.get(screenKey()) ?? 0, busy });
+        const draw = () => {
+            if (closed)
+                return;
+            // A server that is gone after a reload: back to the list.
+            while (stack.length > 1) {
+                const top = screen();
+                if ('name' in top && !controller.getStatuses().some((x) => x.name === top.name))
+                    stack.pop();
+                else
+                    break;
+            }
+            const v = view();
+            // Statuses change while a server connects: keep the focus inside the list.
+            const max = Math.max(0, rowCount(v) - 1);
+            if (v.focus > max) {
+                focusByScreen.set(screenKey(), max);
+                v.focus = max;
+            }
+            block.draw(renderMcpPanel(v, output.columns || 80, output.rows || 30));
+        };
+        const wasRaw = !!input.isRaw;
+        input.setRawMode?.(true);
+        input.resume();
+        const close = () => {
+            if (closed)
+                return;
+            closed = true;
+            input.off('data', onData);
+            block.erase();
+            if (!wasRaw)
+                input.setRawMode?.(false);
+            resolve();
+        };
+        const push = (next) => {
+            stack.push(next);
+            draw();
+        };
+        const back = () => {
+            if (stack.length <= 1)
+                return close();
+            stack.pop();
+            draw();
+        };
+        const setFocus = (delta) => {
+            const v = view();
+            const count = rowCount(v);
+            if (count === 0)
+                return;
+            const next = Math.max(0, Math.min(count - 1, v.focus + delta));
+            if (next !== v.focus) {
+                focusByScreen.set(screenKey(), next);
+                draw();
+            }
+        };
+        /** Runs a slow action with the panel showing "connecting…" and stays on the screen afterwards. */
+        const run = async (action) => {
+            busy = true;
+            draw();
+            try {
+                await action();
+            }
+            catch { }
+            busy = false;
+            draw();
+        };
+        const enter = () => {
+            const v = view();
+            const s = screen();
+            if (s.kind === 'servers') {
+                const server = orderedServers(v.statuses)[v.focus];
+                if (server)
+                    push({ kind: 'server', name: server.name });
+            }
+            else if (s.kind === 'server') {
+                const status = v.statuses.find((x) => x.name === s.name);
+                if (!status)
+                    return;
+                choose(actionsFor(status)[v.focus], status);
+            }
+            else if (s.kind === 'tools') {
+                const tool = v.statuses.find((x) => x.name === s.name)?.toolInfo?.[v.focus];
+                if (tool)
+                    push({ kind: 'tool', name: s.name, tool: tool.name });
+            }
+        };
+        const choose = (action, status) => {
+            if (action === 'tools')
+                push({ kind: 'tools', name: status.name });
+            else if (action === 'reconnect')
+                void run(() => controller.reconnect(status.name));
+            else if (action === 'disable')
+                void run(() => controller.setEnabled(status.name, false));
+            else if (action === 'enable')
+                void run(() => controller.setEnabled(status.name, true));
+        };
+        const handleKey = (key) => {
+            if (key === '\x03')
+                return close();
+            if (busy)
+                return;
+            if (key === '\x1b[A' || key === '\x1bOA' || key === 'k')
+                return setFocus(-1);
+            if (key === '\x1b[B' || key === '\x1bOB' || key === 'j')
+                return setFocus(1);
+            if (key === '\x1b[H' || key === '\x1b[1~' || key === '\x1bOH' || key === 'g')
+                return setFocus(-1e6);
+            if (key === '\x1b[F' || key === '\x1b[4~' || key === '\x1bOF' || key === 'G')
+                return setFocus(1e6);
+            if (key === '\r' || key === '\n' || key === '\x1b[C' || key === '\x1bOC' || key === 'l')
+                return enter();
+            if (key === '\x1b' || key === '\x1b[D' || key === '\x1bOD' || key === 'h')
+                return back();
+            if (key === 'q')
+                return close();
+            if (key === 'r') {
+                const s = screen();
+                if (s.kind === 'servers')
+                    return void run(() => controller.reload());
+                if (s.kind === 'server')
+                    return void run(() => controller.reconnect(s.name));
+            }
+            if (key >= '1' && key <= '9' && screen().kind === 'server') {
+                const s = screen();
+                const status = controller.getStatuses().find((x) => x.name === s.name);
+                if (status)
+                    choose(actionsFor(status)[Number(key) - 1], status);
+            }
+        };
+        const onData = (chunk) => {
+            for (const key of splitKeys(chunk.toString())) {
+                if (closed)
+                    return;
+                handleKey(normalizeKey(key));
+            }
+        };
+        input.on('data', onData);
+        draw();
+    });
+}

package/dist/cli/permission.js

@@ -0,0 +1,84 @@
+import { splitKeys } from './keys.js';
+import { pauseSpinners, renderPermissionCard, renderPermissionChoice, } from './ui.js';
+/** The answers in the order the arrow keys go through them. */
+function choices(offer) {
+    return ['allow', ...(offer.session ? ['session'] : []), ...(offer.always ? ['always'] : []), 'deny'];
+}
+/**
+ * Shows the approval card and waits for a decision:
+ *   y / Enter on Allow  → allow once     n / Esc / Ctrl+C → deny
+ *   s → allow for this session           a → allow always (only when the card offers them)
+ *   ← → Tab h l ↑ ↓     → move the selection
+ * The card is erased once the answer is given (the tool line above stays), and any
+ * running spinner is silenced meanwhile so the two never draw over each other.
+ *
+ * @param defaultAnswer preselected answer; risky requests should start on Deny.
+ */
+export function askPermissionDecision(request, defaultAnswer = 'allow', io = { input: process.stdin, output: process.stdout }, offer = {}) {
+    return new Promise((resolve) => {
+        const { input, output } = io;
+        const resumeSpinner = pauseSpinners();
+        const cols = output.columns || 80;
+        const card = renderPermissionCard(request, cols);
+        const order = choices(offer);
+        let selected = order.includes(defaultAnswer) ? defaultAnswer : 'deny';
+        const wasRaw = !!input.isRaw;
+        input.setRawMode?.(true);
+        input.resume();
+        output.write('\x1b[?25l' + card.join('\n') + '\n' + renderPermissionChoice(selected, cols, offer));
+        const redraw = () => output.write('\r\x1b[2K' + renderPermissionChoice(selected, cols, offer));
+        const finish = (answer) => {
+            input.off('data', onData);
+            // Back to the first row of the card and wipe everything below it.
+            output.write(`\r\x1b[2K${card.length > 0 ? `\x1b[${card.length}A` : ''}\r\x1b[J\x1b[?25h`);
+            if (!wasRaw)
+                input.setRawMode?.(false);
+            resumeSpinner();
+            resolve(answer);
+        };
+        let done = false;
+        const handleKey = (key) => {
+            if (key === '\r' || key === '\n') {
+                done = true;
+                return finish(selected);
+            }
+            if (key === 'y' || key === 'Y') {
+                done = true;
+                return finish('allow');
+            }
+            if ((key === 's' || key === 'S') && offer.session) {
+                done = true;
+                return finish('session');
+            }
+            if ((key === 'a' || key === 'A') && offer.always) {
+                done = true;
+                return finish('always');
+            }
+            if (key === 'n' || key === 'N' || key === 'q' || key === '\x1b' || key === '\x03') {
+                done = true;
+                return finish('deny');
+            }
+            const back = key === '\x1b[D' || key === '\x1bOD' || key === 'h' || key === '\x1b[A' || key === '\x1bOA';
+            const forward = key === '\t' || key === 'l' || key === '\x1b[C' || key === '\x1bOC' || key === '\x1b[B' || key === '\x1bOB';
+            if (back || forward) {
+                const i = order.indexOf(selected);
+                selected = order[(i + (back ? -1 : 1) + order.length) % order.length];
+                redraw();
+            }
+        };
+        // Several key presses can arrive in one chunk (key repeat, batched input); the first
+        // decisive key wins and the rest of the chunk is dropped.
+        const onData = (chunk) => {
+            for (const key of splitKeys(chunk.toString())) {
+                if (done)
+                    return;
+                handleKey(key);
+            }
+        };
+        input.on('data', onData);
+    });
+}
+/** The two-answer form: true when the action is allowed (once). */
+export function askPermission(request, defaultAllow = true, io = { input: process.stdin, output: process.stdout }) {
+    return askPermissionDecision(request, defaultAllow ? 'allow' : 'deny', io).then((answer) => answer !== 'deny');
+}

package/dist/cli/picker.js

@@ -0,0 +1,135 @@
+import { LiveBlock } from './liveblock.js';
+import { splitKeys } from './keys.js';
+import { palette } from './ui.js';
+import { displayWidth, padEndWidth, truncateWidth, wrapWords } from './width.js';
+function hints(width) {
+    const variants = [
+        [['↑↓', 'move'], ['enter', 'select'], ['esc', 'cancel']],
+        [['↑↓', ''], ['enter', ''], ['esc', '']],
+        [['enter', ''], ['esc', '']],
+    ];
+    for (const items of variants) {
+        const text = items.map(([k, label]) => palette.text(k) + (label ? ' ' + palette.faint(label) : '')).join(palette.faint(items[0][1] ? ' · ' : ' '));
+        if (displayWidth(text) <= width)
+            return text;
+    }
+    return '';
+}
+/** Of a long list only the rows around the focus are shown, with "↑ N more" / "↓ N more" at the cut edges. */
+function windowItems(rows, focus, max, width) {
+    if (rows.length <= max)
+        return rows;
+    const start = Math.max(0, Math.min(rows.length - max, focus - Math.floor(max / 2)));
+    const out = rows.slice(start, start + max);
+    const above = start;
+    const below = rows.length - (start + max);
+    if (above > 0)
+        out[0] = { text: ' ' + palette.faint(truncateWidth(`↑ ${above + 1} more`, width)), index: -1 };
+    if (below > 0)
+        out[out.length - 1] = { text: ' ' + palette.faint(truncateWidth(`↓ ${below + 1} more`, width)), index: -1 };
+    return out;
+}
+export function renderPicker(options, focus, cols, termRows = 40) {
+    const labelWidth = options.labelWidth ?? Math.min(10, Math.max(...options.items.map((i) => displayWidth(i.label)), 4)) + 2;
+    const maxItems = Math.max(3, termRows - 7 - (options.notes?.length ?? 0));
+    const row = (item, index, width) => {
+        const focused = index === focus;
+        const isCurrent = options.current !== undefined && item.value === options.current;
+        const mark = focused ? palette.accent('❯') : ' ';
+        const dot = isCurrent ? palette.accent('●') : palette.faint('○');
+        const label = focused ? palette.bold(palette.text(item.label)) : palette.muted(item.label);
+        const prefix = ` ${mark} ${dot} ${padEndWidth(label, labelWidth)}`;
+        const room = Math.max(0, width - displayWidth(prefix) - 1);
+        const detail = item.detail && room > 6 ? palette.faint(truncateWidth(item.detail, room)) : '';
+        return prefix + detail;
+    };
+    // ── phone: no frame
+    if (cols < 60) {
+        const width = Math.max(20, cols - 1);
+        const lines = [' ' + palette.bold(palette.accent(options.title)) + (options.subtitle ? palette.faint(' · ' + truncateWidth(options.subtitle, Math.max(6, width - displayWidth(options.title) - 6))) : '')];
+        const all = options.items.map((item, i) => ({ text: row(item, i, width), index: i }));
+        for (const r of windowItems(all, focus, maxItems, width))
+            lines.push(r.index === focus ? palette.shade(padEndWidth(r.text, width)) : r.text);
+        for (const note of options.notes ?? []) {
+            for (const line of wrapWords(note, width - 2))
+                lines.push(' ' + palette.faint(line));
+        }
+        lines.push(' ' + hints(width - 1));
+        return lines;
+    }
+    // ── card
+    const W = Math.min(cols - 1, 76);
+    const iw = W - 4;
+    const rule = palette.rule;
+    const box = (content, shaded = false) => rule('│') + (shaded ? palette.shade(' ' + padEndWidth(content, iw) + ' ') : ' ' + padEndWidth(content, iw) + ' ') + rule('│');
+    const title = ' ' + palette.bold(palette.accent(options.title)) + ' ';
+    const subtitle = options.subtitle ? ' ' + palette.muted(truncateWidth(options.subtitle, Math.max(6, W - 12 - displayWidth(options.title)))) + ' ' : '';
+    const lines = [rule('╭─') + title + rule('─'.repeat(Math.max(0, W - 4 - displayWidth(title) - displayWidth(subtitle)))) + subtitle + rule('─╮')];
+    lines.push(box(''));
+    const allRows = options.items.map((item, i) => ({ text: row(item, i, iw), index: i }));
+    for (const r of windowItems(allRows, focus, maxItems, iw))
+        lines.push(box(r.text, r.index === focus));
+    const notes = (options.notes ?? []).flatMap((note) => wrapWords(note, iw - 3));
+    if (notes.length > 0) {
+        lines.push(box(''));
+        for (const line of notes)
+            lines.push(box('  ' + palette.faint(line)));
+    }
+    lines.push(rule('╰' + '─'.repeat(W - 2) + '╯'));
+    lines.push(' ' + hints(cols - 2));
+    return lines;
+}
+/** Shows the list and resolves with the chosen value, or undefined when cancelled. */
+export function runPicker(options, io = { input: process.stdin, output: process.stdout }) {
+    return new Promise((resolve) => {
+        const { input, output } = io;
+        const block = new LiveBlock(output);
+        const count = options.items.length;
+        let focus = Math.max(0, options.items.findIndex((i) => options.current !== undefined && i.value === options.current));
+        let done = false;
+        const draw = () => block.draw(renderPicker(options, focus, output.columns || 80, output.rows || 40));
+        const wasRaw = !!input.isRaw;
+        input.setRawMode?.(true);
+        input.resume();
+        const finish = (value) => {
+            done = true;
+            input.off('data', onData);
+            block.erase();
+            if (!wasRaw)
+                input.setRawMode?.(false);
+            resolve(value);
+        };
+        const move = (delta) => {
+            const next = Math.max(0, Math.min(count - 1, focus + delta));
+            if (next !== focus) {
+                focus = next;
+                draw();
+            }
+        };
+        const handleKey = (key) => {
+            if (key === '\x1b[A' || key === '\x1bOA' || key === 'k')
+                return move(-1);
+            if (key === '\x1b[B' || key === '\x1bOB' || key === 'j')
+                return move(1);
+            if (key === '\x1b[H' || key === '\x1b[1~' || key === '\x1bOH' || key === 'g')
+                return move(-count);
+            if (key === '\x1b[F' || key === '\x1b[4~' || key === '\x1bOF' || key === 'G')
+                return move(count);
+            if (key === '\r' || key === '\n' || key === ' ')
+                return finish(options.items[focus].value);
+            if (key >= '1' && key <= '9' && Number(key) <= count)
+                return finish(options.items[Number(key) - 1].value);
+            if (key === '\x1b' || key === 'q' || key === '\x03')
+                return finish(undefined);
+        };
+        const onData = (chunk) => {
+            for (const key of splitKeys(chunk.toString())) {
+                if (done)
+                    return;
+                handleKey(key);
+            }
+        };
+        input.on('data', onData);
+        draw();
+    });
+}