termux-dev 1.8.2 → 1.9.1

package/dist/cli/index.js

@@ -26,13 +26,15 @@ import { savePlanFile } from '../core/planfile.js';
 import { BASE_TITLE, RESTORE_TERMINAL_TITLE, SAVE_TERMINAL_TITLE, cleanTitle, generateChatTitle, provisionalTitle, terminalTitleSequence } from '../core/title.js';
 import { runDoctor } from './doctor.js';
 import { ALL_PROVIDERS } from './providers.js';
+import { addProviderFlow, manageProviderFlow } from './provider-manager.js';
+import { NO_KEY, hostOfUrl, isCustomProvider, keyHint, listCustomProviders, migrateLegacyCustom, providerDisplayName } from '../core/custom-providers.js';
 import { getModelContextInfo, getModelContextLimit } from '../core/models.js';
 import { SessionManager } from '../core/session.js';
 import { MarkdownStreamer, renderMarkdown } from './markdown.js';
 import { SmoothStreamer } from './smooth.js';
 import { askPrompt } from './prompt.js';
 import { resolveAtMentions } from './files.js';
-import { runStartupUpdateCheck, checkForUpdates, performSelfUpdate } from './updater.js';
+import { runManualUpdate, runStartupUpdateCheck } from './update-screen.js';
 import { setActiveTheme, getCurrentTheme, listThemes, findTheme } from './theme.js';
 import { runHeadlessMode } from './headless.js';
 import { CustomCommandManager } from '../core/commands.js';
@@ -141,7 +143,7 @@ async function fetchModels(baseUrl, apiKey) {
             if (apiKey)
                 headers['x-api-key'] = apiKey;
         }
-        else if (apiKey && apiKey !== 'ollama') {
+        else if (apiKey && apiKey !== 'ollama' && apiKey !== NO_KEY) {
             headers['Authorization'] = `Bearer ${apiKey}`;
         }
         const res = await fetch(url, { headers });
@@ -248,12 +250,21 @@ async function selectModel(baseUrl, apiKey, currentModel, providerId = '', _allo
 /** The host of an address, for the detail column: `api.openai.com`. */
 const hostOf = (url) => url.replace(/^https?:\/\//, '').replace(/\/.*$/, '');
 async function selectProvider(currentConfig, allowCancel = true) {
-    const apiKeys = currentConfig.apiKeys || {};
-    const baseUrls = currentConfig.baseUrls || {};
+    // The maps are shared with the config, so what the provider screens change is seen by both.
+    const apiKeys = (currentConfig.apiKeys = currentConfig.apiKeys || {});
+    const baseUrls = (currentConfig.baseUrls = currentConfig.baseUrls || {});
     if (currentConfig.provider && currentConfig.apiKey) {
         apiKeys[currentConfig.provider] = currentConfig.apiKey;
     }
+    // The single "Custom" of older versions becomes a saved provider with a name of its own.
+    migrateLegacyCustom(currentConfig);
     const firstRun = !allowCancel;
+    const providerFlow = {
+        // The first-run setup saves everything once, at its end.
+        save: firstRun ? undefined : saveConfig,
+        listedIds: ALL_PROVIDERS.map((pr) => pr.value),
+    };
+    const ADD = '__add__';
     const stepOf = (n) => (firstRun ? `${n}/5` : undefined);
     let providerId = '';
     let baseUrl = '';
@@ -268,20 +279,44 @@ async function selectProvider(currentConfig, allowCancel = true) {
                 placeholder: t('onboard.provider.placeholder'),
                 current: currentConfig.provider,
                 notes: firstRun ? [t('onboard.provider.note')] : undefined,
-                items: ALL_PROVIDERS.map((pr) => ({
-                    value: pr.value,
-                    label: pr.label,
-                    detail: `${apiKeys[pr.value] ? maskApiKey(apiKeys[pr.value]) + '  ' : ''}${hostOf(pr.baseUrl || '')}`.trim(),
-                    keywords: `${pr.value} ${hostOf(pr.baseUrl || '')}`,
-                    pinned: pr.value === 'custom',
-                })),
+                items: [
+                    { value: ADD, label: t('provider.add'), detail: t('provider.addDetail'), pinned: true },
+                    // The providers the user saved come first, then the long list of known ones.
+                    ...listCustomProviders(currentConfig).map((c) => ({
+                        value: c.id,
+                        label: c.name,
+                        detail: `${t('provider.customTag')} · ${[keyHint(c.apiKey), hostOfUrl(c.baseUrl)].filter(Boolean).join('  ')}`,
+                        keywords: `${c.id} ${hostOfUrl(c.baseUrl)} ${t('provider.customTag')}`,
+                    })),
+                    ...ALL_PROVIDERS.map((pr) => ({
+                        value: pr.value,
+                        label: pr.label,
+                        detail: `${apiKeys[pr.value] ? maskApiKey(apiKeys[pr.value]) + '  ' : ''}${hostOf(pr.baseUrl || '')}`.trim(),
+                        keywords: `${pr.value} ${hostOf(pr.baseUrl || '')}`,
+                    })),
+                ],
             });
             if (choice === undefined)
                 return null; // Esc on the first step leaves the whole setup
+            if (choice === ADD || isCustomProvider(currentConfig, choice)) {
+                // A provider of the user's own: add one, or use / change / delete a saved one.
+                let id = choice;
+                if (choice === ADD)
+                    id = await addProviderFlow(currentConfig, providerFlow);
+                else if ((await manageProviderFlow(currentConfig, choice, providerFlow)) !== 'use')
+                    id = null;
+                if (!id)
+                    continue; // back to the list (it shows the changes)
+                providerId = id;
+                baseUrl = currentConfig.customProviders[id].baseUrl;
+                apiKey = apiKeys[id] ?? '';
+                stage = apiKey ? 'model' : 'key';
+                continue;
+            }
             providerId = choice;
             const known = ALL_PROVIDERS.find(pr => pr.value === providerId);
             baseUrl = baseUrls[providerId] || known?.baseUrl || '';
-            stage = providerId === 'custom' || !baseUrl ? 'url' : 'key';
+            stage = !baseUrl ? 'url' : 'key';
         }
         else if (stage === 'url') {
             const url = await runTextInput({
@@ -300,8 +335,8 @@ async function selectProvider(currentConfig, allowCancel = true) {
             stage = 'key';
         }
         else if (stage === 'key') {
-            const label = ALL_PROVIDERS.find(pr => pr.value === providerId)?.label || providerId;
-            const back = providerId === 'custom' || !(ALL_PROVIDERS.find(pr => pr.value === providerId)?.baseUrl) ? 'url' : 'provider';
+            const label = providerDisplayName(currentConfig, providerId, ALL_PROVIDERS);
+            const back = isCustomProvider(currentConfig, providerId) ? 'provider' : !(ALL_PROVIDERS.find(pr => pr.value === providerId)?.baseUrl) ? 'url' : 'provider';
             if (providerId === 'ollama') {
                 apiKey = 'ollama';
                 stage = 'model';
@@ -348,7 +383,7 @@ async function selectProvider(currentConfig, allowCancel = true) {
         else {
             modelRes = await selectModel(baseUrl, apiKey, currentConfig.model || '', providerId, allowCancel, stepOf(5));
             if (!modelRes)
-                stage = apiKey === 'ollama' ? 'provider' : 'key';
+                stage = apiKey === 'ollama' || isCustomProvider(currentConfig, providerId) ? 'provider' : 'key';
         }
     }
     const updatedConfig = {
@@ -715,6 +750,7 @@ async function handleSettings(config) {
         layout: config.ui?.layout === 'classic' ? 'classic' : 'clean',
         pureBlack: config.pureBlackTheme !== false,
         autoApprove: !!config.autoApprove,
+        extra: !!config.autoApprove && !!config.autoApproveAll,
         maxIterations: config.maxIterations || 100,
         memory: config.enableMemory !== false,
         updates: config.checkUpdates !== false,
@@ -745,12 +781,20 @@ async function handleSettings(config) {
     config.banner = final.layout === 'clean' ? (config.banner === 'off' ? 'off' : 'clean') : 'full';
     config.pureBlackTheme = final.pureBlack;
     config.autoApprove = final.autoApprove;
+    // Extra goes with YOLO and, like YOLO, is never saved: it is off again at the next start.
+    const extraWasOn = !!initial.extra;
+    config.autoApproveAll = final.autoApprove && !!final.extra;
     config.maxIterations = final.maxIterations;
     config.enableMemory = final.memory;
     config.checkUpdates = final.updates;
     config.language = final.language;
     config.maxCostPerSession = final.costLimit;
     await saveConfig(config);
+    // Said once more where it cannot be missed, when the panel is closed with Extra newly switched on.
+    if (config.autoApproveAll && !extraWasOn) {
+        console.log(renderNotice('warn', t('settings.extraEnabled')));
+        console.log();
+    }
     process.stdin.resume();
     return config;
 }
@@ -789,6 +833,7 @@ export async function main() {
         .version(DEVX_VERSION)
         .option('-p, --prompt <task>', 'Run one-shot task non-interactively (headless mode)')
         .option('-y, --yolo', 'Automatically approve all tool executions without confirmation')
+        .option('--extra', 'Like --yolo, but nothing is asked at all: dangerous commands and credential files too (use only where you can afford to lose everything)')
         .option('-m, --model <model>', 'Specify AI model to use for this execution')
         .option('-q, --quiet', 'Quiet output in headless mode (suppress banners and tool logs)')
         .option('--json', 'Output structured JSON in headless mode')
@@ -812,9 +857,12 @@ export async function main() {
     }
     // -m and the project config are for this run: only what changes from here on is saved.
     markConfigBaseline(config);
-    if (options.yolo) {
+    if (options.yolo || options.extra) {
         config.autoApprove = true;
     }
+    if (options.extra) {
+        config.autoApproveAll = true;
+    }
     if (options.effort !== undefined) {
         // One run only (never saved). Anything the model does not offer is ignored with a warning.
         // A custom endpoint is asked about the model first (cached, a few seconds at most).
@@ -844,6 +892,7 @@ export async function main() {
         const exitCode = await runHeadlessMode(options.prompt, config, {
             planMode: planModeInitial,
             yolo: !!options.yolo,
+            extra: !!options.extra,
             quiet: !!options.quiet,
             json: !!options.json,
             signal: abortController.signal
@@ -857,11 +906,12 @@ export async function main() {
         return {
             version: DEVX_VERSION,
             model: modelLabel(config),
-            provider: config.provider,
+            provider: providerDisplayName(config, config.provider, ALL_PROVIDERS),
             cwd: process.cwd(),
             branch: git?.branch,
             dirty: git?.isDirty,
             yolo: !!config.autoApprove,
+            extra: !!config.autoApprove && !!config.autoApproveAll,
             tip: pickTip(),
         };
     };
@@ -884,11 +934,36 @@ export async function main() {
     history.addMessage({ role: 'system', content: sysPrompt });
     const sessionManager = new SessionManager(config.model, planMode);
     drawLogo(config.banner || 'full');
-    await runStartupUpdateCheck(config);
+    await runStartupUpdateCheck(config, { save: saveConfig });
     await MCPManager.getInstance().init(undefined, config.projectMcpTrusted === true);
     // Ask a custom endpoint what the current model can do (cached for a day; never blocks the prompt).
     void refreshEndpoint(config).catch(() => null);
     const sessionCost = new CostLedger();
+    // For the small side jobs (chat title, commit message, summary): the lightest reasoning the model
+    // offers, and what they cost goes into the session total like everything else.
+    const sideProvider = () => {
+        const inner = createProvider(config, { light: true });
+        return {
+            id: inner.id,
+            chat: async (request) => {
+                try {
+                    const res = await inner.chat(request);
+                    if (res.usage)
+                        sessionCost.add(res.usage);
+                    return res;
+                }
+                catch (err) {
+                    // Timed out or cut off after the request went out: still billed, so it counts as an estimate.
+                    if (err?.status === undefined || err.status === 504 || err.status === 524) {
+                        const lost = inner.lostRequestUsage?.(new History().estimateTokens(request.messages), 0);
+                        if (lost)
+                            sessionCost.add(lost);
+                    }
+                    throw err;
+                }
+            },
+        };
+    };
     const currentContext = () => contextBreakdown(history.getMessages(), getTools(planMode).map(t => t.definition), config.maxContextTokens || getModelContextLimit(config.model));
     let currentDraft = '';
     let autoTriggerPrompt = '';
@@ -903,8 +978,7 @@ export async function main() {
     const permissionMemory = newPermissionMemory();
     // Commands the agent keeps running in the background (servers, watchers): shown in the prompt frame, listed by /tasks.
     const bg = getBackgroundManager();
-    const seenBgFailures = new Set();
-    const bgSummary = () => backgroundSummary(bg, seenBgFailures);
+    const bgSummary = () => backgroundSummary(bg);
     // The most a session may cost (USD, 0 = no limit); "continue" at the limit raises it for this session only.
     let costLimitRaised = null;
     let costWarned = false;
@@ -937,7 +1011,6 @@ export async function main() {
         await bg.stopAll().catch(() => 0);
         bg.clearFinished();
         bg.takeNotes();
-        seenBgFailures.clear();
         transcript.length = 0;
         checkpoints.length = 0;
         windowTitle = '';
@@ -964,10 +1037,10 @@ export async function main() {
     while (true) {
         const maxTokens = config.maxContextTokens || getModelContextLimit(config.model);
         config.maxContextTokens = maxTokens;
-        // The conversation only: the system prompt and tool schemas are fixed overhead that every
-        // chat has, so an empty chat shows 0%. /usage shows the full picture.
+        // An empty chat shows 0; from the first message on, everything the next request carries
+        // is counted: the system prompt and the tool schemas too.
         const ctxNow = currentContext();
-        const currentTokens = ctxNow.total - ctxNow.system - ctxNow.tools;
+        const currentTokens = ctxNow.inUse;
         const usagePercent = Math.min(100, Math.round((currentTokens / maxTokens) * 100));
         const formatTokens = (n) => {
             if (n >= 1_000_000)
@@ -1044,6 +1117,7 @@ export async function main() {
                 },
                 planMode,
                 isYolo: !!config.autoApprove,
+                isExtra: !!config.autoApprove && !!config.autoApproveAll,
                 ui: config.ui,
                 model: modelLabel(config),
                 cwd: process.cwd(),
@@ -1201,20 +1275,7 @@ export async function main() {
                 continue;
             }
             if (cmd === '/update') {
-                const s = new UiSpinner();
-                s.start('Checking for updates from https://github.com/apvcode/Termux-Dev...');
-                const res = await checkForUpdates(10000);
-                s.stop();
-                if (res.updateAvailable) {
-                    log.info(pc.bold(pc.yellow(`Update available: v${res.currentVersion} → v${res.latestVersion}`)));
-                    const doUpdate = await askConfirm({ title: 'update', question: t('confirm.update', { version: res.latestVersion }), initial: true });
-                    if (doUpdate) {
-                        await performSelfUpdate(res.latestVersion);
-                    }
-                }
-                else {
-                    log.success(pc.green(`devx is up to date! (v${res.currentVersion})`));
-                }
+                await runManualUpdate();
                 continue;
             }
             if (cmd === '/help') {
@@ -1283,6 +1344,8 @@ export async function main() {
                         planMode = loaded.planMode;
                     }
                     sessionCost.restore(loaded.totalCost || 0, loaded.costEstimated === true);
+                    // /usage starts from the same total as the frame, and not from the chat that was open before.
+                    UsageTracker.getInstance().restoreCost(loaded.totalCost || 0, loaded.costEstimated === true);
                     drawLogo(config.banner || 'full');
                     const nonSysMessages = loaded.messages.filter(m => m.role !== 'system');
                     const totalMsgs = nonSysMessages.length;
@@ -1440,7 +1503,7 @@ export async function main() {
                         const s = new UiSpinner();
                         s.start('Generating conventional commit message with AI...');
                         await refreshFormats(config).catch(() => null);
-                        const provider = createProvider(config);
+                        const provider = sideProvider();
                         const promptReq = {
                             messages: [
                                 {
@@ -1482,7 +1545,7 @@ export async function main() {
                 s.start('Compacting conversation context with AI...');
                 try {
                     await refreshFormats(config).catch(() => null);
-                    const provider = createProvider(config);
+                    const provider = sideProvider();
                     // The request itself must fit the window: shorten a copy of the history first.
                     const forSummary = new History();
                     for (const m of msgs)
@@ -1552,7 +1615,7 @@ export async function main() {
                 continue;
             }
             if (cmd === '/tasks' || cmd === '/bg' || cmd === '/jobs') {
-                const rows = await runTasksCommand(parts.slice(1).filter(Boolean), bg, process.stdout.columns || 80, (ids) => ids.forEach((id) => seenBgFailures.add(id)));
+                const rows = await runTasksCommand(parts.slice(1).filter(Boolean), bg, process.stdout.columns || 80);
                 console.log(rows.join('\n'));
                 console.log();
                 continue;
@@ -1677,7 +1740,7 @@ export async function main() {
                         log.warn(t('rename.usage'));
                     }
                     else {
-                        const generated = await generateChatTitle(createProvider(config), firstUser.split('\n\n--- Attached Files ---')[0], reply);
+                        const generated = await generateChatTitle(sideProvider(), firstUser.split('\n\n--- Attached Files ---')[0], reply);
                         if (!generated)
                             log.error(t('rename.failed'));
                         else {
@@ -1938,7 +2001,7 @@ export async function main() {
                 if (newConfig) {
                     config = newConfig;
                     await refreshEndpoint(config).catch(() => null);
-                    announce(`provider ${config.provider || 'custom'} · ${config.model}${providerFormat(config) === 'anthropic' ? ' (Anthropic format)' : ''}`);
+                    announce(`provider ${providerDisplayName(config, config.provider, ALL_PROVIDERS) || config.provider || 'custom'} · ${config.model}${providerFormat(config) === 'anthropic' ? ' (Anthropic format)' : ''}`);
                 }
                 else {
                     log.info('Provider selection cancelled.');
@@ -2046,6 +2109,7 @@ export async function main() {
         const provider = createProvider(config);
         const tools = getTools(planMode);
         const guard = new CLIConsoleGuard(config.autoApprove, [...(config.bashAllowlist || [])], {
+            extra: !!config.autoApproveAll,
             memory: permissionMemory,
             // "Always": kept in the config for the next sessions (`/permissions` lists and clears them).
             onAlways: (r) => {
@@ -2279,9 +2343,7 @@ export async function main() {
                 pendingRedraw = true;
             }
         };
-        // Ctrl+Enter: what the user typed goes to the agent right now, replacing the task it was on.
-        let interruptPrompt = '';
-        const stopGeneration = (quiet = false, reason) => {
+        const stopGeneration = (reason) => {
             if (aborted)
                 return;
             aborted = true;
@@ -2299,14 +2361,6 @@ export async function main() {
                 console.log(renderNotice('warn', reason));
                 console.log();
             }
-            else if (quiet) {
-                // The message that caused the stop is echoed by the next turn: only a quiet separator here.
-                if (cleanUi)
-                    console.log(renderNotice('info', t('stop.interrupted')));
-                else
-                    console.log(pc.yellow('\n' + t('stop.classicInterrupted')));
-                console.log();
-            }
             else if (cleanUi) {
                 console.log(renderNotice('warn', isConnecting ? t('stop.connection') : t('stop.stopped')));
                 console.log();
@@ -2321,13 +2375,6 @@ export async function main() {
         const onSigInt = () => {
             stopGeneration();
         };
-        const sendQueuedNow = () => {
-            if (aborted)
-                return;
-            interruptPrompt = composer.takeQueued().join('\n');
-            if (interruptPrompt)
-                stopGeneration(true);
-        };
         // The input line at the bottom while the agent works: what is typed there is queued and
         // reaches the model at its next step (see TurnComposer).
         // The working line (time and tokens) stays above the frame for the whole turn.
@@ -2343,10 +2390,10 @@ export async function main() {
         });
         const composer = new TurnComposer(process.stdout, () => {
             const ctx = currentContext();
-            const used = ctx.total - ctx.system - ctx.tools;
+            const used = ctx.inUse;
             const git = GitStatusCache.getStatus();
             return {
-                mode: resolveMode(planMode, !!config.autoApprove),
+                mode: resolveMode(planMode, !!config.autoApprove, !!config.autoApproveAll),
                 model: modelLabel(config),
                 cwd: process.cwd(),
                 branch: git?.branch,
@@ -2356,7 +2403,7 @@ export async function main() {
                 costState: sessionCost.state(),
                 background: bgSummary(),
             };
-        }, undefined, statusLine, sendQueuedNow);
+        }, undefined, statusLine);
         // A task started or ended during the turn: the frame shows the new count.
         const onBgChange = () => composer.refresh();
         bg.on('change', onBgChange);
@@ -2380,6 +2427,16 @@ export async function main() {
                 stopGeneration();
                 return;
             }
+            // Esc stops the answer and whatever it started (a command that runs), like Ctrl+C. Not while a
+            // card has the keyboard: there Esc answers the card. A lone Esc comes in a chunk of its own;
+            // Esc followed by a character in one chunk is Alt+that character.
+            if (!composer.isSuspended) {
+                const keys = splitKeys(text);
+                if (keys.length === 1 && normalizeKey(keys[0]) === '\x1b') {
+                    stopGeneration();
+                    return;
+                }
+            }
             composer.handleData(text);
         };
         const onResize = () => composer.onResize();
@@ -2419,8 +2476,14 @@ export async function main() {
                 takeNotes: () => bg.takeNotes(),
                 hasNotes: () => bg.hasNotes(),
             })) {
-                if (aborted)
+                if (aborted) {
+                    // The request that was cancelled is still billed by the provider: its estimate counts.
+                    if (event.type === 'usage') {
+                        sessionCost.add(event.usage);
+                        turnInputTokens += event.usage.promptTokens || 0;
+                    }
                     break;
+                }
                 if (event.type === 'reasoning_delta') {
                     isConnecting = false;
                     telemetry.setPhase('thinking');
@@ -2624,7 +2687,7 @@ export async function main() {
                     const limit = costLimit();
                     if (limit > 0 && !aborted) {
                         if (sessionCost.total >= limit) {
-                            stopGeneration(false, t('cost.stopped', { limit: formatCost(limit) }));
+                            stopGeneration(t('cost.stopped', { limit: formatCost(limit) }));
                         }
                         else if (!costWarned && sessionCost.total >= limit * 0.8) {
                             costWarned = true;
@@ -2735,12 +2798,7 @@ export async function main() {
             // a message that arrived too late for the agent starts the next turn by itself.
             bg.off('change', onBgChange);
             const leftover = composer.stop();
-            if (interruptPrompt) {
-                autoTriggerPrompt = interruptPrompt;
-                if (leftover.draft)
-                    currentDraft = leftover.draft;
-            }
-            else if (leftover.queued.length > 0) {
+            if (leftover.queued.length > 0) {
                 if (aborted)
                     currentDraft = [...leftover.queued, leftover.draft].filter(Boolean).join(' ');
                 else
@@ -2795,7 +2853,7 @@ export async function main() {
                     const forSession = sessionManager.getSession().id;
                     void (async () => {
                         try {
-                            const title = await generateChatTitle(createProvider(config), firstUser.split('\n\n--- Attached Files ---')[0], reply);
+                            const title = await generateChatTitle(sideProvider(), firstUser.split('\n\n--- Attached Files ---')[0], reply);
                             // The user may have started another chat meanwhile.
                             if (!title || sessionManager.getSession().id !== forSession)
                                 return;
@@ -2863,8 +2921,6 @@ export async function main() {
             const unsent = composer.stop();
             if (process.stdout.isTTY)
                 process.stdout.write('\x1b[?1004l');
-            if (interruptPrompt && !autoTriggerPrompt)
-                autoTriggerPrompt = interruptPrompt;
             releasePauseHook();
             process.stdout.removeListener('resize', onResize);
             if (!currentDraft && (unsent.draft || unsent.queued.length > 0)) {

package/dist/cli/keys.js

@@ -13,11 +13,20 @@ export function splitKeys(chunk) {
 }
 /** Erases the word before the cursor (Ctrl+W in a shell); Ctrl+Backspace and Alt+Backspace are mapped to it. */
 export const WORD_BACKSPACE = '\x17';
-/** What a terminal sends for Ctrl+Enter once the extended keyboard modes below are on. */
+/**
+ * What a terminal sends for Ctrl+Enter once the extended keyboard modes below are on. Ctrl+Enter
+ * and Alt+Enter break the line (a new paragraph) instead of sending it, like Shift+Enter.
+ */
 export const CTRL_ENTER = '\x1b[13;5u';
+/** Shift+Enter in the two extended encodings (a plain terminal sends the same byte as for Enter). */
+const SHIFT_ENTER = /^\x1b\[(?:13;2u|27;2;13~)$/;
+/** Does this key break the line instead of sending it? Ctrl+Enter, Alt+Enter and Shift+Enter, as far as the terminal tells them from Enter. */
+export function isNewlineKey(key) {
+    return normalizeKey(key) === CTRL_ENTER || SHIFT_ENTER.test(key);
+}
 /**
- * Asks the terminal to tell Ctrl+Enter apart from Enter (a plain terminal sends the same
- * byte for both). Two protocols are requested, a terminal answers the one it knows:
+ * Asks the terminal to tell Ctrl+Enter and Shift+Enter apart from Enter (a plain terminal sends
+ * the same byte for all of them). Two protocols are requested, a terminal answers the one it knows:
  * the kitty keyboard protocol (kitty, foot, ghostty, wezterm, alacritty, ...) and xterm's
  * modifyOtherKeys. Terminals that know neither ignore both, and Alt+Enter still works.
  * While on, the keys arrive as `CSI … u`: run them through `normalizeKey`.

package/dist/cli/liveblock.js

@@ -1,3 +1,4 @@
+import { displayWidth } from './width.js';
 /**
  * A block of terminal rows that is redrawn in place.
  *
@@ -5,41 +6,78 @@
  * rewrites every row and wipes the rows left over from a taller previous version, so the
  * screen never grows however often the content changes. The cursor is hidden while the
  * block is on screen.
+ *
+ * The way back up is counted in rows of the screen, not in lines of the block: when the window
+ * gets narrower the terminal wraps the lines it already drew onto more rows, and going up by the
+ * number of lines would leave the top of the old block on screen (the block would show up twice).
  */
 export class LiveBlock {
     out;
-    rows = 0;
+    /** Visible width of each line of the block as it was drawn. */
+    widths = [];
     constructor(out) {
         this.out = out;
     }
+    /** Number of lines of the block on screen. */
     get height() {
-        return this.rows;
+        return this.widths.length;
+    }
+    columns() {
+        return Math.max(1, this.out.columns || process.stdout.columns || 80);
+    }
+    /** Rows of the screen the given lines take at the current width. */
+    rowsOf(widths) {
+        const cols = this.columns();
+        return widths.reduce((n, w) => n + Math.max(1, Math.ceil(w / cols)), 0);
     }
     draw(lines) {
+        const before = this.rowsOf(this.widths);
         let buf = '\x1b[?25l';
-        if (this.rows > 1)
-            buf += `\x1b[${this.rows - 1}A`;
+        if (before > 1)
+            buf += `\x1b[${before - 1}A`;
         buf += '\r';
         lines.forEach((line, i) => {
             buf += '\x1b[2K' + line + '\x1b[0m' + (i < lines.length - 1 ? '\n' : '');
         });
+        const widths = lines.map((line) => displayWidth(line));
+        const now = this.rowsOf(widths);
         let extra = 0;
-        for (let k = lines.length; k < this.rows; k++) {
+        for (let k = now; k < before; k++) {
             buf += '\n\x1b[2K';
             extra++;
         }
         if (extra > 0)
             buf += `\x1b[${extra}A`;
         this.out.write(buf);
-        this.rows = lines.length;
+        this.widths = widths;
     }
     /** Removes the block from the screen and shows the cursor again. */
     erase() {
-        if (this.rows === 0) {
+        const rows = this.rowsOf(this.widths);
+        if (rows === 0) {
+            this.out.write('\x1b[?25h');
+            return;
+        }
+        this.out.write(`\r${rows > 1 ? `\x1b[${rows - 1}A` : ''}\x1b[J\x1b[?25h`);
+        this.widths = [];
+    }
+    /** Leaves what is drawn on the screen as it is: the cursor comes back under it and the next draw starts a new block. */
+    release() {
+        if (this.widths.length === 0) {
             this.out.write('\x1b[?25h');
             return;
         }
-        this.out.write(`\r${this.rows > 1 ? `\x1b[${this.rows - 1}A` : ''}\x1b[J\x1b[?25h`);
-        this.rows = 0;
+        this.out.write('\n\x1b[?25h');
+        this.widths = [];
+    }
+    /**
+     * Calls `redraw` when the window is resized, so the block is drawn again at the new width.
+     * Returns the function that stops watching (call it when the panel closes).
+     */
+    watchResize(redraw) {
+        this.out.on?.('resize', redraw);
+        return () => {
+            this.out.off?.('resize', redraw);
+        };
     }
 }

package/dist/cli/mcp-panel.js

@@ -314,11 +314,13 @@ export function runMcpPanel(controller, options = {}) {
         const wasRaw = !!input.isRaw;
         input.setRawMode?.(true);
         input.resume();
+        const stopWatching = block.watchResize(draw);
         const close = () => {
             if (closed)
                 return;
             closed = true;
             input.off('data', onData);
+            stopWatching();
             block.erase();
             if (!wasRaw)
                 input.setRawMode?.(false);

package/dist/cli/picker.js

@@ -99,9 +99,11 @@ export function runPicker(options, io = { input: process.stdin, output: process.
         const wasRaw = !!input.isRaw;
         input.setRawMode?.(true);
         input.resume();
+        const stopWatching = block.watchResize(draw);
         const finish = (value) => {
             done = true;
             input.off('data', onData);
+            stopWatching();
             block.erase();
             if (!wasRaw)
                 input.setRawMode?.(false);