zames_pro 2.5.0 → 2.6.0

package/README.md

@@ -60,6 +60,38 @@ zames --help
 Global config: `~/.zames/config.json`
 Local (per project): `.zamesrc.json`
 
+You can view and change settings without leaving the agent — use the
+`/config` command. Run it without arguments to open an interactive menu
+(↑/↓ to move, Enter to change, `d` to reset, `q` to quit). Booleans and enums
+toggle in place; numbers and strings open an input prompt.
+
+```
+/config                       interactive settings menu
+/config list                  print all editable settings
+/config get <path>            show a setting
+/config set <path> <value>    change a setting
+/config reset <path>          reset a setting to its default
+/config path                  show config file paths
+/config lang <ru|en>          switch interface and agent language
+```
+
+Examples:
+
+```
+/config set maxIterations 20
+/config set confirmation.bash false
+/config lang en
+```
+
+Changes are written to the project `.zamesrc.json` and applied right away
+(where possible without a restart).
+
+### Language
+
+`/config lang ru` or `/config lang en` switches both the interface language
+(help, messages, spinner) and the language the agent answers you in. The
+locale lives in `ui.locale` in the config file.
+
 Agent data is stored in `~/.zames`: browser profile, logs, undo history, self-review snapshots.
 
 ## License

package/dist/agent-loop.js

@@ -1,7 +1,7 @@
 import { buildSystemPrompt } from './system-prompt.js';
 import { getGitContext, formatGitContext } from './gitTools.js';
 import { parseXmlToolCalls } from './xml-toolcall.js';
-export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 40, freshChat = false, sendSystemPrompt = false, transcript = null, onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, debugLog = false, }) {
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 40, freshChat = false, sendSystemPrompt = false, transcript = null, onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, debugLog = false, locale = 'ru', }) {
     if (freshChat) {
         await browser.newChat();
         transcript?.log('new_chat');
@@ -35,6 +35,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             workdir,
             tools,
             gitContext: gitText,
+            locale,
         });
         transcript?.log('system_prompt', {
             length: systemPrompt.length,
@@ -51,6 +52,13 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     const MAX_MALFORMED_RETRIES = 3;
     let stallRetries = 0;
     const MAX_STALL_RETRIES = 5;
+    // Защита от «агент встал»: DeepSeek иногда присылает финальный текст,
+    // который лишь ОПИСЫВАЕТ следующий вызов инструмента (или рвёт ответ на
+    // полуслове), и агент молча завершает задачу, хотя работа не сделана.
+    // Если финальный ответ похож на «сейчас вызову …» — переспрашиваем, а не
+    // останавливаемся. Счётчик общий, чтобы не зациклиться на болтливой модели.
+    let looksDoneRetries = 0;
+    const MAX_LOOKSDONE_RETRIES = 3;
     for (let i = 0; i < maxIterations; i++) {
         onThinking();
         // Первое сообщение (task) — пользовательский ввод: без паузы.
@@ -83,10 +91,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             // только явный JSON, но и XML/DSML-формы, «грязные» варианты и
             // незакрытые фрагменты: если такой ответ молча принять за финальный,
             // агент встанет, хотя модель пыталась позвать инструмент.
-            const looksLikeToolCall = /("tool"\s*:|\btool_calls?\b|\binvoke\b|\bparameter\b|DSML|function_call)/i.test(rawResponse) ||
-                /\{\s*"?(tool|name|args)"?\s*:/.test(rawResponse) ||
-                /<\s*\|?\s*(DSML|invoke|parameter)/i.test(rawResponse) ||
-                /^\s*\[?\s*\{[^}]*$/.test(rawResponse.trim());
+            const looksLikeToolCall = responseLooksLikeToolCall(rawResponse);
             if (looksLikeToolCall && malformedRetries < MAX_MALFORMED_RETRIES) {
                 malformedRetries++;
                 transcript?.log('malformed_toolcall', {
@@ -108,10 +113,16 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                 continue;
             }
             const trimmed = (rawResponse || '').trim();
+            // Служебный ответ — это КОРОТКАЯ заглушка DeepSeek («Reading…») или
+            // короткое уведомление о лимите. Слова про rate limit в ДЛИННОМ
+            // ответе — это, как правило, сам агент цитирует код/логи (в транскрипте
+            // был ровно такой случай: ответ на 1365 символов про ask() и лимиты),
+            // и принимать его за «служебный» нельзя, иначе агент зря переспрашивает.
             const looksService = !trimmed ||
                 trimmed.length < 2 ||
                 /^(reading|thinking|searching|analyzing|generating|stop|остановить|читаю|думаю|поиск|анализ)[\s.…]*$/i.test(trimmed) ||
-                /(messages? too frequent|too many requests|rate limit|слишком часто|try again later)/i.test(trimmed);
+                (trimmed.length <= 200 &&
+                    /(messages? too frequent|too many requests|rate limit|слишком часто|try again later)/i.test(trimmed));
             if (looksService && stallRetries < MAX_STALL_RETRIES) {
                 stallRetries++;
                 transcript?.log('stall_retry', {
@@ -131,6 +142,32 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                         'Если задача выполнена — вызови инструмент respond с итоговым сообщением.';
                 continue;
             }
+            // Ответ похож на «сейчас вызову инструмент», но вызова в нём нет.
+            // DeepSeek иногда так обрывает ход: пишет «Now update README…» или
+            // «Let me run the tests…» и замолкает. Если принять это за финал,
+            // агент встаёт, не сделав работу. Просим продолжить и на этот раз
+            // обязательно вызвать инструмент (или respond, если правда готово).
+            if (looksLikeUnfinishedWork(trimmed) && looksDoneRetries < MAX_LOOKSDONE_RETRIES) {
+                looksDoneRetries++;
+                transcript?.log('unfinished_retry', {
+                    attempt: looksDoneRetries,
+                    response: rawResponse,
+                });
+                if (debugLog) {
+                    console.error('внимание: ответ похож на незавершённую работу, прошу продолжить (попытка ' +
+                        looksDoneRetries +
+                        '/' +
+                        MAX_LOOKSDONE_RETRIES +
+                        ')');
+                }
+                message =
+                    'Похоже, ты собирался вызвать инструмент, но не вызвал. ' +
+                        'Если задача ещё не выполнена — ответь РОВНО одним JSON-объектом ' +
+                        'вызова инструмента, без текста до и после. ' +
+                        'Если задача действительно выполнена — вызови respond с итоговым ' +
+                        'сообщением оператору.';
+                continue;
+            }
             onAssistantMessage(rawResponse);
             transcript?.log('assistant_final', { message: rawResponse });
             return rawResponse;
@@ -206,6 +243,52 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     }
     return 'Достигнут лимит итераций.';
 }
+// Ответ похож на вызов инструмента, но parseToolCall() его не распознал.
+// Используется как страховка от «агент вызвал инструмент и остановился»:
+// в этом случае runAgentLoop просит модель переотправить вызов, а не
+// завершает задачу. Ловим и явные форматы, и «поломанные» головы вызова
+// (`<｜tool": ...`, `**tool**:`, `tool": ...`), и обрезанные вызовы.
+export function responseLooksLikeToolCall(rawResponse) {
+    const raw = rawResponse || '';
+    return (
+    // Явные маркеры форматов tool-call: JSON-ключ "tool", XML/DSML-теги,
+    // function_call и т.п.
+    /("tool"\s*:|\btool_calls?\b|\binvoke\b|\bparameter\b|DSML|function_call)/i.test(raw) ||
+        // «tool» без открывающей кавычки/скобки, с мусорным префиксом
+        // (`<｜tool":`, `**tool**:`, `- tool:`): ключ вызова, а не проза.
+        /(^|[^A-Za-z0-9_])(?:\*\*)?tool(?:\*\*)?["'`\u2018\u2019\u201c\u201d]*\s*:/.test(raw) ||
+        // Ключи в одинарных кавычках или без кавычек: {'tool': 'Read', ...}.
+        /[\{\[]\s*['"]?(tool|name|args)['"]?\s*:/.test(raw) ||
+        // Обрезанный вызов: начинается как JSON-объект, но не закрыт, и в нём
+        // есть ключ аргумента (args/command/path/...). Требуем именно открывающую
+        // скобку в начале (после пробелов/префикса), чтобы не ловить обычную
+        // прозу с двоеточиями вроде «path: ...».
+        /^\s*[\[\{]/.test(raw) &&
+            /["']?(?:tool|args|command|path|old_string|content|content_base64)["']?\s*:/.test(raw) ||
+        /<\s*\|?\s*(DSML|invoke|parameter)/i.test(raw) ||
+        /^\s*\[?\s*\{[^}]*$/.test(raw.trim()));
+}
+// Текст, который обещает вызов инструмента в будущем времени, но самого
+// вызова не содержит. DeepSeek регулярно так «зависает»: пишет
+// «Now update README to mention …», «Let me run the tests», «Сейчас проверю»
+// и останавливается. Такие ответы нельзя принимать за финальные — иначе
+// агент встаёт, не выполнив работу. Держим эвристику узкой (будущее время /
+// намерение), чтобы не ловить обычные отчёты о выполненной работе.
+function looksLikeUnfinishedWork(text) {
+    const t = (text || '').trim();
+    if (!t)
+        return false;
+    // Длинные ответы (отчёты) не трогаем — там может быть что угодно.
+    if (t.length > 600)
+        return false;
+    // Уже есть финальный маркер — считаем ответ завершённым.
+    if (/\b(done|finished|completed|готово|выполнено|завершено)\b/i.test(t)) {
+        return false;
+    }
+    const en = /\b(now|next|then|let me|let's|i will|i'll|i am going to|i'm going to|going to|about to|will now|time to)\b[^.!?\n]{0,120}\b(update|write|edit|read|run|check|add|fix|create|remove|delete|apply|test|commit|push|install|open|search|look|verify|change|modify|implement|review)\b/i;
+    const ru = /(^|[^а-яё])(проверю|обновлю|исправлю|добавлю|запущу|выполню|посмотрю|прочитаю|изменю|попробую|сделаю)([^а-яё]|$)/i;
+    return en.test(t) || ru.test(t);
+}
 // ============ JSON parsing ============
 function repairRawControlChars(str) {
     let out = '';
@@ -639,6 +722,81 @@ function findMatching(text, openIdx, openCh, closeCh) {
     }
     return -1;
 }
+// Модель иногда отдаёт вызов инструмента с ключами/строками в одинарных
+// кавычках («{'tool': 'Read', 'args': {...}}») или с ключами без кавычек
+// («{tool: "Read", args: {...}}»). Это не валидный JSON, и без нормализации
+// такой ответ молча принимается за финальный — агент встаёт, не вызвав
+// инструмент. Приводим его к двойным кавычкам.
+function normalizePseudoJson(str) {
+    // Ключи без кавычек: {tool: ...} или , args: ... → "tool": / "args":
+    let out = str.replace(/([\{\[]\s*)([A-Za-z_][A-Za-z0-9_]*)\s*:/g, '$1"$2":');
+    out = out.replace(/,\s*([A-Za-z_][A-Za-z0-9_]*)\s*:/g, ', "$1":');
+    // Одинарные кавычки → двойные. Не трогаем содержимое уже двойных строк,
+    // идущее подряд, и экранируем случайные двойные внутри одинарных.
+    let res = '';
+    let inDouble = false;
+    let inSingle = false;
+    for (let i = 0; i < out.length; i++) {
+        const c = out[i];
+        if (c === '\\' && (inDouble || inSingle)) {
+            res += c;
+            if (i + 1 < out.length) {
+                res += out[i + 1];
+                i++;
+            }
+            continue;
+        }
+        if (c === '"' && !inSingle) {
+            inDouble = !inDouble;
+            res += c;
+            continue;
+        }
+        if (c === "'" && !inDouble) {
+            if (!inSingle) {
+                inSingle = true;
+                res += '"';
+            }
+            else {
+                inSingle = false;
+                res += '"';
+            }
+            continue;
+        }
+        if (inSingle && c === '"') {
+            res += '\\"';
+            continue;
+        }
+        res += c;
+    }
+    return res;
+}
+// Модель иногда портит начало вызова: `<｜tool": "Bash", "args": {...}`,
+// `tool": "Read", ...`, `**tool**: ...`, `- tool: ...`. В таких ответах
+// нет открывающей `{`, а ключ `tool` лишился первой кавычки. Если такой
+// ответ принять за финальный, агент молча встанет (частая «остановка»).
+// Восстанавливаем: срезаем мусорный префикс до слова tool, добавляем `{` и
+// доводим кавычки ключа до парных.
+function repairToolCallPreamble(text) {
+    const t = (text || '').trim();
+    const m = t.match(/(?:^|[^A-Za-z0-9_])(?:\*\*)?(tool)(?:\*\*)?["'`\u2018\u2019\u201c\u201d]*\s*:/);
+    if (!m || m.index === undefined)
+        return null;
+    // Начало ищем с первой кавычки/скобки вокруг ключа, иначе — с слова tool.
+    let start = m.index;
+    const brace = t.indexOf('{', Math.max(0, start - 1));
+    if (brace !== -1 && brace < start)
+        start = brace;
+    let frag = t.slice(start);
+    // Если фрагмент не начинается с `{` — добавляем его.
+    if (!frag.startsWith('{')) {
+        // Ключ мог потерять открывающую кавычку: tool": → "tool":.
+        // Срезаем ведущий мусор до слова tool и нормализуем кавычки ключа.
+        frag = frag.replace(/^[^A-Za-z0-9_]*/, '');
+        frag = frag.replace(/^(?:\*\*)?(["'`\u2018\u2019\u201c\u201d]*)(tool)(?:\*\*)?["'`\u2018\u2019\u201c\u201d]*\s*:/, '"$2":');
+        frag = '{' + frag;
+    }
+    return frag;
+}
 export function parseToolCall(text) {
     if (!text || typeof text !== 'string')
         return null;
@@ -671,8 +829,24 @@ export function parseToolCall(text) {
         if (ctrlArr)
             return ctrlArr;
     }
+    // Псевдо-JSON (одинарные кавычки / ключи без кавычек) — нормализуем и
+    // пробуем распарсить как обычный вызов, прежде чем идти в permissive.
+    if (/['"]?tool['"]?\s*:/.test(cleaned)) {
+        const norm = normalizePseudoJson(cleaned);
+        if (norm !== cleaned) {
+            for (const raw of extractJsonObjects(norm)) {
+                const a = tryParseArray(raw);
+                if (a)
+                    return a;
+                const o = tryParse(raw);
+                if (o)
+                    return o;
+            }
+        }
+    }
     const permissive = parseToolCallPermissive(cleaned) ||
-        parseToolCallPermissive(repairRawControlChars(cleaned));
+        parseToolCallPermissive(repairRawControlChars(cleaned)) ||
+        parseToolCallPermissive(normalizePseudoJson(cleaned));
     if (permissive)
         return { ...permissive, _permissive: true };
     const toolIdx = cleaned.search(/["']?tool["']?\s:/);
@@ -687,6 +861,31 @@ export function parseToolCall(text) {
     const xmlCalls = parseXmlToolCalls(cleaned);
     if (xmlCalls)
         return Array.isArray(xmlCalls) ? xmlCalls : [xmlCalls];
+    // Последняя попытка: «починить» испорченную голову вызова (`<｜tool": ...`,
+    // `tool": ...`, `**tool**: ...`, `- tool: ...`). Делаем это ТОЛЬКО как
+    // fallback, после обычного разбора — иначе легко испортить валидный JSON
+    // (например, массив вызовов начинается с `[`, внутри которого `{"tool":`).
+    const preamble = repairToolCallPreamble(cleaned);
+    if (preamble && preamble !== cleaned) {
+        const reps = [
+            preamble,
+            repairRawControlChars(preamble),
+            normalizePseudoJson(preamble),
+        ];
+        for (const rep of reps) {
+            for (const raw of extractJsonObjects(rep)) {
+                const a = tryParseArray(raw);
+                if (a)
+                    return a;
+                const o = tryParse(raw);
+                if (o)
+                    return o;
+            }
+        }
+        const perm = parseToolCallPermissive(preamble);
+        if (perm)
+            return { ...perm, _permissive: true };
+    }
     return null;
 }
 function extractPreToolText(text) {

package/dist/browser.js

@@ -506,7 +506,7 @@ export class DeepSeekBrowser {
         const gap = this.minSendIntervalMs - (Date.now() - this._lastSentAt);
         if (gap <= 0)
             return;
-        console.error(theme.warn(`⏳ пауза ${Math.ceil(gap / 1000)}с перед отправкой...`));
+        console.error(theme.warn(`⏳ пауза ${Math.ceil(gap / 1000)}с перед отправкой`));
         await this.page.waitForTimeout(gap);
     }
     async _askOnce(prompt, { timeout, agent }) {

package/dist/config-menu.js

@@ -0,0 +1,231 @@
+// Интерактивное меню настроек для команды /config.
+//
+// Меню рисует список параметров, сгруппированных по секциям, и позволяет
+// менять их стрелками: boolean/enum переключаются на месте, number/string
+// запрашивают ввод. Все строки берутся из i18n (cfg.*), поэтому меню
+// полностью локализовано.
+//
+// Модуль не знает про config.ts напрямую (кроме типов схемы): чтение и
+// запись значений делает вызывающий через колбэки. Так меню легко тестировать
+// и переиспользовать.
+import { theme } from './theme.js';
+const ESC = String.fromCharCode(27);
+// Убираем ANSI-последовательности, чтобы посчитать видимую длину строки.
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');
+}
+function displayValue(field, value, t) {
+    if (value === undefined)
+        return t('cfg.menu.default');
+    if (typeof value === 'boolean')
+        return value ? t('common.on') : t('common.off');
+    return String(value);
+}
+function groupLabel(field, t) {
+    return t(field.groupKey);
+}
+/**
+ * Показать интерактивное меню. Возвращает промис, который резолвится, когда
+ * пользователь вышел (q/Esc/Ctrl+C). В не-TTY бросает ошибку — вызывающий
+ * должен показать текстовый список.
+ */
+export function runConfigMenu(opts) {
+    const input = opts.input || process.stdin;
+    const output = opts.output || process.stdout;
+    const { fields, t, get, set, reset } = opts;
+    if (!input.isTTY || !input.setRawMode) {
+        return Promise.reject(new Error(t('cfg.menu.notty')));
+    }
+    let cursor = 0;
+    let editing = false;
+    let editBuf = '';
+    let message = null;
+    let exited = false;
+    let resolveDone = null;
+    const wasRaw = input.isRaw;
+    input.setRawMode(true);
+    input.resume();
+    output.write(ESC + '[?25l'); // прячем курсор на время отрисовки
+    // Отрисовка меню: строки идут сверху вниз, курсор возвращаем в начало
+    // блока через относительные перемещения, чтобы не плодить пустые строки.
+    let lastRows = 0;
+    const render = () => {
+        const lines = [];
+        lines.push(theme.bold(t('cfg.menu.title')));
+        let lastGroup = '';
+        for (let i = 0; i < fields.length; i++) {
+            const f = fields[i];
+            const g = groupLabel(f, t);
+            if (g !== lastGroup) {
+                lines.push(theme.system('  ' + g));
+                lastGroup = g;
+            }
+            const selected = i === cursor;
+            const marker = selected ? theme.prompt('\u276f ') : '  ';
+            const label = selected ? theme.prompt(f.labelKey ? t(f.labelKey) : f.path) : t(f.labelKey || f.path);
+            const val = displayValue(f, get(f.path), t);
+            const valText = selected ? theme.assistant(val) : theme.dim(val);
+            const pathText = selected ? theme.dim('  ' + f.path) : '';
+            lines.push(marker + label + theme.dim('  =  ') + valText + pathText);
+        }
+        if (editing) {
+            lines.push('');
+            lines.push(theme.user(t('cfg.menu.edit_hint')));
+            lines.push(theme.prompt('\u276f ') + editBuf);
+        }
+        else if (message) {
+            lines.push('');
+            lines.push(theme.assistant(message));
+        }
+        else {
+            lines.push('');
+            lines.push(theme.dim(t('cfg.menu.hint')));
+        }
+        // Стираем прошлый блок и печатаем новый. Считаем ВИЗУАЛЬНЫЕ строки
+        // (с учётом переноса по ширине терминала), иначе на узких терминалах
+        // остаётся «мусор» из нестёртых хвостов.
+        const cols = output.columns || 80;
+        const rowsOf = (s) => {
+            const len = stripAnsi(s).length;
+            return Math.max(1, Math.ceil(len / Math.max(1, cols)));
+        };
+        if (lastRows > 0) {
+            output.write(ESC + '[' + lastRows + 'A');
+            for (let i = 0; i < lastRows; i++) {
+                output.write(ESC + '[2K' + ESC + '[1B');
+            }
+            output.write(ESC + '[' + lastRows + 'A');
+        }
+        output.write(lines.join('\n') + '\n');
+        lastRows = lines.reduce((n, l) => n + rowsOf(l), 0);
+    };
+    const cleanup = () => {
+        if (exited)
+            return;
+        exited = true;
+        input.removeListener('data', onData);
+        if (input.setRawMode)
+            input.setRawMode(wasRaw || false);
+        output.write(ESC + '[?25h'); // возвращаем курсор
+        if (resolveDone)
+            resolveDone();
+    };
+    const commitEdit = () => {
+        const f = fields[cursor];
+        const raw = editBuf.trim();
+        editing = false;
+        editBuf = '';
+        if (!raw) {
+            message = null;
+            return;
+        }
+        try {
+            set(f, raw);
+            message = t('cfg.menu.saved', {
+                v: f.path,
+                value: displayValue(f, get(f.path), t),
+            });
+        }
+        catch (e) {
+            message = String(e.message || e);
+        }
+    };
+    const toggle = () => {
+        const f = fields[cursor];
+        if (f.type === 'boolean') {
+            const cur = get(f.path);
+            set(f, cur === true ? 'false' : 'true');
+            message = null;
+            return;
+        }
+        if (f.type === 'enum' && f.values && f.values.length) {
+            const cur = String(get(f.path) ?? '');
+            const idx = f.values.indexOf(cur);
+            const next = f.values[(idx + 1) % f.values.length];
+            set(f, next);
+            message = null;
+            return;
+        }
+        // number/string — запрашиваем ввод.
+        editing = true;
+        editBuf = get(f.path) === undefined ? '' : String(get(f.path));
+    };
+    const onData = (buf) => {
+        const s = buf.toString('utf-8');
+        if (editing) {
+            // Обрабатываем ввод посимвольно: терминал может прислать несколько
+            // байт сразу (вставка, авто-повтор), Enter — 0x0d/0x0a, backspace — 0x7f.
+            for (const ch of s) {
+                if (ch === '\r' || ch === '\n') {
+                    commitEdit();
+                    break;
+                }
+                if (ch === ESC) {
+                    editing = false;
+                    editBuf = '';
+                    break;
+                }
+                if (ch === '\x03') {
+                    cleanup();
+                    output.write('\n');
+                    return;
+                }
+                if (ch === '\x7f' || ch === '\b') {
+                    editBuf = editBuf.slice(0, -1);
+                }
+                else if (ch >= ' ') {
+                    editBuf += ch;
+                }
+            }
+            render();
+            return;
+        }
+        // Терминал может прислать несколько клавиш одним пакетом (быстрый набор,
+        // авто-повтор, автоматизация). Разбираем буфер по токенам: сначала
+        // escape-последовательности (стрелки), затем одиночные символы.
+        let i = 0;
+        while (i < s.length) {
+            if (s.startsWith('\x1b[A', i)) {
+                cursor = (cursor - 1 + fields.length) % fields.length;
+                message = null;
+                i += 3;
+                continue;
+            }
+            if (s.startsWith('\x1b[B', i)) {
+                cursor = (cursor + 1) % fields.length;
+                message = null;
+                i += 3;
+                continue;
+            }
+            const ch = s[i];
+            if (ch === 'q' || ch === 'Q' || ch === '\x03' || ch === ESC) {
+                cleanup();
+                output.write('\n');
+                return;
+            }
+            if (ch === 'k') {
+                cursor = (cursor - 1 + fields.length) % fields.length;
+                message = null;
+            }
+            else if (ch === 'j') {
+                cursor = (cursor + 1) % fields.length;
+                message = null;
+            }
+            else if (ch === '\r' || ch === '\n' || ch === ' ') {
+                toggle();
+            }
+            else if (ch === 'd' || ch === 'D') {
+                const f = fields[cursor];
+                reset(f);
+                message = t('cfg.reset', { v: f.path });
+            }
+            i++;
+        }
+        render();
+    };
+    return new Promise((resolve) => {
+        resolveDone = resolve;
+        input.on('data', onData);
+        render();
+    });
+}