cli-surf 0.11.0 → 0.12.1

package/cliPrompt.js

@@ -53,6 +53,38 @@ function stripAnsi(text) {
     }
     return out;
 }
+export function getCursorPos(text, cursor) {
+    const safeCursor = Math.max(0, Math.min(cursor, text.length));
+    const before = text.slice(0, safeCursor);
+    const lines = before.split('\n');
+    return {
+        line: lines.length - 1,
+        col: lines[lines.length - 1].length,
+    };
+}
+export function getCursorFromPos(text, pos) {
+    const lines = text.split('\n');
+    const targetLine = Math.max(0, Math.min(pos.line, lines.length - 1));
+    let idx = 0;
+    for (let i = 0; i < targetLine; i += 1) {
+        idx += lines[i].length + 1;
+    }
+    const targetCol = Math.max(0, Math.min(pos.col, lines[targetLine].length));
+    return idx + targetCol;
+}
+export function isNewlineKey(s) {
+    return (s === '\n' || // LF (Ctrl+J, or standard Ctrl+Enter in many terminals)
+        s === '\x1b\r' || // Alt+Enter / Meta+Enter
+        s === '\x1b\n' || // Alt+Ctrl+Enter
+        s === '\x1b[13;5u' || // Kitty keyboard protocol: Ctrl+Enter
+        s === '\x1b[13;2u' || // Kitty keyboard protocol: Shift+Enter
+        s === '\x1b[13;3u' || // Kitty keyboard protocol: Alt+Enter
+        s === '\x1b[27;5;13~' || // xterm / win32 modified: Ctrl+Enter
+        s === '\x1b[27;2;13~' || // xterm / win32 modified: Shift+Enter
+        s === '\x1b[27;3;13~' || // xterm / win32 modified: Alt+Enter
+        s === '\x0e' // Ctrl+N (convenient fallback)
+    );
+}
 /**
  * Одна строка ввода с живыми подсказками.
  * Возвращает текст и вложения из дропа (токены [image N]/[file N] в тексте).
@@ -124,6 +156,7 @@ export async function promptMenuLine(opts) {
         return null;
     };
     let finish = null;
+    let cursorRow = 0;
     const done = (value) => {
         stdin.removeListener('data', onData);
         try {
@@ -131,19 +164,32 @@ export async function promptMenuLine(opts) {
         }
         catch { /* уже не raw */ }
         stdin.pause();
+        stdout.write('\x1b[?2004l'); // отключаем bracketed paste
         stdout.write('\x1b[?25h');
         if (value === null) {
             eraseDrawn();
             stdout.write('\r\x1b[2K');
         }
         else {
-            eraseDrawn();
-            stdout.write(`\r\x1b[${pw + buffer.length}C\n`);
+            if (menuOpen) {
+                menuOpen = false;
+                render();
+            }
+            const bufLines = buffer.split('\n');
+            const targetRow = bufLines.length - 1;
+            const distDown = targetRow - cursorRow;
+            if (distDown > 0)
+                stdout.write(`\x1b[${distDown}B`);
+            stdout.write(`\r\x1b[${pw + bufLines[targetRow].length}C\n`);
             stdout.write('\x1b[J');
         }
         finish?.({ line: value, attachments });
     };
     const eraseDrawn = () => {
+        if (cursorRow > 0) {
+            stdout.write(`\x1b[${cursorRow}A\r`);
+            cursorRow = 0;
+        }
         if (drawn === 0)
             return;
         let s = '';
@@ -155,7 +201,12 @@ export async function promptMenuLine(opts) {
     };
     const render = () => {
         eraseDrawn();
-        const rows = [`${prompt}${paintTokens(buffer)}`];
+        const bufLines = buffer.split('\n');
+        const indent = ' '.repeat(pw);
+        const rows = bufLines.map((line, idx) => {
+            const pfx = idx === 0 ? prompt : indent;
+            return `${pfx}${paintTokens(line)}`;
+        });
         if (menuOpen) {
             matches.slice(menuOffset, menuOffset + MAX_ROWS).forEach((m, row) => {
                 const i = menuOffset + row;
@@ -167,11 +218,13 @@ export async function promptMenuLine(opts) {
             });
         }
         stdout.write(`\r${rows.map(l => `\x1b[K${l}`).join('\n')}`);
-        drawn = menuOpen ? Math.min(matches.length, MAX_ROWS) : 0;
-        const up = rows.length - 1;
-        if (up > 0)
-            stdout.write(`\x1b[${up}A`);
-        stdout.write(`\r\x1b[${pw + cursor}C`);
+        drawn = rows.length - 1;
+        const pos = getCursorPos(buffer, cursor);
+        cursorRow = pos.line;
+        const distUp = (rows.length - 1) - cursorRow;
+        if (distUp > 0)
+            stdout.write(`\x1b[${distUp}A`);
+        stdout.write(`\r\x1b[${pw + pos.col}C`);
     };
     const insert = (text) => {
         buffer = buffer.slice(0, cursor) + text + buffer.slice(cursor);
@@ -180,6 +233,10 @@ export async function promptMenuLine(opts) {
         refreshMenu();
         render();
     };
+    const insertNewline = () => {
+        menuOpen = false;
+        insert('\n');
+    };
     const submit = () => {
         if (menuOpen && matches[sel] && buffer !== matches[sel].value) {
             // Как в Claude: Enter дополняет недопечатанное, а не отправляет.
@@ -239,10 +296,14 @@ export async function promptMenuLine(opts) {
         render();
     };
     function onData(buf) {
-        const s = buf.toString('utf8');
-        switch (s) {
+        const raw = buf.toString('utf8');
+        const cleanInput = raw.replace(/\x1b\[200~/g, '').replace(/\x1b\[201~/g, '');
+        if (isNewlineKey(cleanInput)) {
+            insertNewline();
+            return;
+        }
+        switch (cleanInput) {
             case '\r':
-            case '\n':
                 submit();
                 return;
             case '\t':
@@ -283,7 +344,14 @@ export async function promptMenuLine(opts) {
                     render();
                 }
                 else {
-                    moveHist(-1);
+                    const pos = getCursorPos(buffer, cursor);
+                    if (pos.line > 0) {
+                        cursor = getCursorFromPos(buffer, { line: pos.line - 1, col: pos.col });
+                        render();
+                    }
+                    else {
+                        moveHist(-1);
+                    }
                 }
                 return;
             case '\x1b[B':
@@ -294,7 +362,15 @@ export async function promptMenuLine(opts) {
                     render();
                 }
                 else {
-                    moveHist(1);
+                    const pos = getCursorPos(buffer, cursor);
+                    const bufLines = buffer.split('\n');
+                    if (pos.line < bufLines.length - 1) {
+                        cursor = getCursorFromPos(buffer, { line: pos.line + 1, col: pos.col });
+                        render();
+                    }
+                    else {
+                        moveHist(1);
+                    }
                 }
                 return;
             case '\x1b[C':
@@ -355,7 +431,12 @@ export async function promptMenuLine(opts) {
                 killWord();
                 return;
             case '\x03':
-                done(null);
+                if (buffer.length > 0) {
+                    resetLine('');
+                }
+                else {
+                    done(null);
+                }
                 return;
             case '\x04':
                 if (buffer.length === 0)
@@ -366,12 +447,15 @@ export async function promptMenuLine(opts) {
         }
         // Неизвестные escape-последовательности (F1-F12 и т.п.) — игнор целиком,
         // иначе их хвост впечатается в строку (как было с PgUp → «[5~»).
-        if (s.charCodeAt(0) === 0x1b)
+        if (cleanInput.charCodeAt(0) === 0x1b)
             return;
         // Одиночные управляющие — игнор; остальное (включая вставки) — в буфер.
-        if (s.length === 1 && (s.charCodeAt(0) < 0x20 || s.charCodeAt(0) === 0x7f))
+        if (cleanInput.length === 1 && (cleanInput.charCodeAt(0) < 0x20 || cleanInput.charCodeAt(0) === 0x7f))
             return;
-        const clean = [...s].filter(c => {
+        const normalized = cleanInput.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        const clean = [...normalized].filter(c => {
+            if (c === '\n')
+                return true;
             const n = c.codePointAt(0) ?? 0;
             return (n >= 0x20 && n < 0x7f) || n >= 0xa0;
         }).join('');
@@ -403,6 +487,7 @@ export async function promptMenuLine(opts) {
         stdin.on('data', onData);
         stdin.setRawMode(true);
         stdin.resume();
+        stdout.write('\x1b[?2004h'); // включаем bracketed paste
         stdout.write('\x1b[?25l');
     });
 }
@@ -410,6 +495,8 @@ export const CHAT_COMMANDS = [
     { value: '/usage', desc: { ru: 'общий лимит', en: 'shared limit' }, takesArg: false },
     { value: '/model', desc: { ru: 'выбор модели', en: 'choose a model' }, takesArg: true },
     { value: '/permissions', desc: { ru: 'разрешения агента', en: 'agent permissions' }, takesArg: false },
+    { value: '/open', desc: { ru: 'открыть файл', en: 'open file' }, takesArg: true },
+    { value: '/get', desc: { ru: 'скачать файл', en: 'download file' }, takesArg: true },
     { value: '/clear', desc: { ru: 'очистить историю', en: 'clear history' }, takesArg: false },
     { value: '/help', desc: { ru: 'команды', en: 'commands' }, takesArg: false },
     { value: '/skills', desc: { ru: 'навыки агента', en: 'agent skills' }, takesArg: false },

package/cliTools.js

@@ -11,6 +11,7 @@ import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import { paint } from './cliUi.js';
 import { discoverSkills, loadSkill, builtinSkillsDir, userSkillsDir, projectSkillsDir } from './cliSkills.js';
+import { loadMcpConfig, connectMcpServer } from './cliMcp.js';
 export const CODE_TOOLS = [
     {
         type: 'function',
@@ -122,8 +123,231 @@ export const CODE_TOOLS = [
         },
     },
 ];
-export function createToolContext(cwd, yesAll, permissionMode = 'important') {
-    return { cwd: path.resolve(cwd), yesAll, permissionMode, readFiles: new Set() };
+/**
+ * Парсинг содержимого .env файла:
+ * - Игнорирует пустые строки и комментарии (#)
+ * - Поддерживает KEY=VALUE, KEY="VAL\nUE", KEY='VALUE'
+ * - Отрезает инлайн-комментарии (#) для значений без кавычек
+ */
+export function parseEnv(content) {
+    const result = {};
+    const lines = content.split(/\r?\n/);
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const eqIdx = line.indexOf('=');
+        if (eqIdx <= 0)
+            continue;
+        const key = line.slice(0, eqIdx).trim();
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+            continue;
+        let val = line.slice(eqIdx + 1).trim();
+        if ((val.startsWith('"') && val.endsWith('"') && val.length >= 2) ||
+            (val.startsWith("'") && val.endsWith("'") && val.length >= 2)) {
+            const isDouble = val.startsWith('"');
+            val = val.slice(1, -1);
+            if (isDouble) {
+                val = val.replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t');
+            }
+        }
+        else {
+            const hashIdx = val.indexOf(' #');
+            if (hashIdx >= 0) {
+                val = val.slice(0, hashIdx).trim();
+            }
+        }
+        result[key] = val;
+    }
+    return result;
+}
+/**
+ * Подгрузка .env и .env.local из папки проекта в process.env без перезаписи существующих переменных.
+ */
+export function loadProjectEnv(cwd) {
+    const loaded = {};
+    const envFiles = ['.env', '.env.local'];
+    for (const file of envFiles) {
+        const fullPath = path.resolve(cwd, file);
+        try {
+            if (fs.existsSync(fullPath)) {
+                const text = fs.readFileSync(fullPath, 'utf8');
+                const parsed = parseEnv(text);
+                for (const [key, val] of Object.entries(parsed)) {
+                    if (!(key in process.env)) {
+                        process.env[key] = val;
+                        loaded[key] = val;
+                    }
+                }
+            }
+        }
+        catch { /* игнорируем ошибки чтения .env */ }
+    }
+    return loaded;
+}
+function findWindowsGitBash() {
+    if (process.platform !== 'win32')
+        return null;
+    const candidates = [
+        'C:\\Program Files\\Git\\bin\\bash.exe',
+        'C:\\Program Files\\Git\\usr\\bin\\bash.exe',
+        'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+        'C:\\Program Files (x86)\\Git\\usr\\bin\\bash.exe',
+    ];
+    const localAppData = process.env.LOCALAPPDATA;
+    if (localAppData) {
+        candidates.push(path.join(localAppData, 'Programs', 'Git', 'bin', 'bash.exe'));
+        candidates.push(path.join(localAppData, 'Programs', 'Git', 'usr', 'bin', 'bash.exe'));
+    }
+    for (const c of candidates) {
+        try {
+            if (fs.existsSync(c))
+                return c;
+        }
+        catch { /* ignore */ }
+    }
+    return null;
+}
+function findWindowsPowerShell() {
+    if (process.platform !== 'win32')
+        return null;
+    const sysRoot = process.env.SystemRoot || 'C:\\Windows';
+    const winPs = path.join(sysRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+    try {
+        if (fs.existsSync(winPs))
+            return winPs;
+    }
+    catch { /* ignore */ }
+    return 'powershell.exe';
+}
+/**
+ * Определение оптимальной оболочки для запуска команд.
+ * На Windows отдаёт предпочтение Git Bash (для поддержки POSIX-команд моделей LLM:
+ * export, grep, rm -rf, ls -la, touch, cat, pipes), затем PowerShell Core / Windows PowerShell, затем cmd.exe.
+ * На Unix использует process.env.SHELL или /bin/sh.
+ */
+export function resolveShell(customShell) {
+    if (customShell && customShell.trim()) {
+        const trimmed = customShell.trim();
+        const lower = trimmed.toLowerCase();
+        if (lower === 'bash' || lower.endsWith('bash.exe') || lower.endsWith('/bash')) {
+            const found = findWindowsGitBash();
+            return { shell: found || (process.platform === 'win32' ? 'bash.exe' : '/bin/bash'), isBash: true, type: 'bash' };
+        }
+        if (lower === 'powershell' || lower === 'powershell.exe') {
+            return { shell: 'powershell.exe', isBash: false, type: 'powershell' };
+        }
+        if (lower === 'pwsh' || lower === 'pwsh.exe') {
+            return { shell: 'pwsh.exe', isBash: false, type: 'pwsh' };
+        }
+        if (lower === 'cmd' || lower === 'cmd.exe') {
+            return { shell: process.env.ComSpec || 'cmd.exe', isBash: false, type: 'cmd' };
+        }
+        const isBash = lower.includes('bash');
+        return { shell: trimmed, isBash, type: isBash ? 'bash' : 'custom' };
+    }
+    if (process.platform !== 'win32') {
+        const sh = process.env.SHELL || '/bin/sh';
+        return { shell: sh, isBash: sh.includes('bash'), type: 'unix' };
+    }
+    const gitBash = findWindowsGitBash();
+    if (gitBash) {
+        return { shell: gitBash, isBash: true, type: 'bash' };
+    }
+    const psPath = findWindowsPowerShell();
+    if (psPath) {
+        return { shell: psPath, isBash: false, type: psPath.includes('pwsh') ? 'pwsh' : 'powershell' };
+    }
+    return { shell: process.env.ComSpec || 'cmd.exe', isBash: false, type: 'cmd' };
+}
+export function createToolContext(cwd, yesAll, permissionMode = 'important', shell) {
+    loadProjectEnv(cwd);
+    return { cwd: path.resolve(cwd), yesAll, permissionMode, readFiles: new Set(), mcpClients: new Map(), mcpTools: [], shell };
+}
+/** Имя инструмента MCP в общем пространстве: mcp__server__tool. */
+export function mcpToolName(server, tool) {
+    return `mcp__${server}__${tool}`;
+}
+function splitMcpName(name) {
+    const m = name.match(/^mcp__([A-Za-z0-9][A-Za-z0-9_-]*)__(.+)$/);
+    if (!m)
+        return null;
+    return { server: m[1], tool: m[2] };
+}
+/**
+ * Подключить все настроенные MCP-серверы, собрать их инструменты.
+ * Вызывать раз за сессию чата; падающие серверы пропускаем с предупреждением.
+ */
+export async function initMcp(ctx) {
+    const { servers } = loadMcpConfig(ctx.cwd);
+    const names = Object.keys(servers);
+    if (names.length === 0)
+        return [];
+    const defs = [];
+    for (const name of names) {
+        const cfg = servers[name];
+        try {
+            const client = await connectMcpServer(name, cfg);
+            ctx.mcpClients.set(name, client);
+            for (const tool of client.tools) {
+                let schemaJson = '';
+                try {
+                    schemaJson = JSON.stringify(tool.inputSchema);
+                }
+                catch {
+                    continue;
+                }
+                if (schemaJson.length > 7000) {
+                    console.error(`${paint('MCP', 'gray')} ${paint(name, 'white')}: инструмент ${tool.name} пропущен (схема > 7КБ)`);
+                    continue;
+                }
+                defs.push({
+                    type: 'function',
+                    function: {
+                        name: mcpToolName(name, tool.name),
+                        description: `[MCP ${name}] ${tool.description || tool.name}`.slice(0, 1900),
+                        parameters: tool.inputSchema,
+                    },
+                });
+            }
+            console.error(`${paint('MCP', 'gray')} ${paint(name, 'white')}: ${paint(`${client.tools.length} инструментов`, 'gray')}`);
+        }
+        catch (err) {
+            console.error(`${paint('MCP', 'gray')} ${paint(name, 'white')}: ${paint(`не подключился: ${err.message}`, 'yellow')}`);
+        }
+    }
+    ctx.mcpTools = defs;
+    return defs;
+}
+export function closeMcpClients(ctx) {
+    for (const [, client] of ctx.mcpClients) {
+        try {
+            client.close();
+        }
+        catch { /* ignore */ }
+    }
+    ctx.mcpClients.clear();
+}
+async function toolMcpCall(ctx, server, tool, args) {
+    const client = ctx.mcpClients.get(server);
+    if (!client)
+        return `ошибка: MCP-сервер «${server}» не подключён`;
+    const cfg = loadMcpConfig(ctx.cwd).servers[server];
+    const timeoutMs = cfg?.timeout ?? 60000;
+    const run = () => client.call(tool, args, timeoutMs);
+    if (!requiresApproval(ctx, 'mcp'))
+        return run();
+    if (!process.stdin.isTTY)
+        return 'отклонено: неинтерактивный режим без --yes';
+    const decision = await askApproval(`MCP ${server}.${tool} — выполнить?`, ctx);
+    if (decision === 'no')
+        return 'отклонено пользователем';
+    try {
+        return await run();
+    }
+    catch (err) {
+        return `ошибка MCP: ${err.message}`;
+    }
 }
 const RESULT_CAP = 12000;
 function truncateResult(text) {
@@ -323,6 +547,9 @@ function requiresApproval(ctx, kind, bashCommand) {
         return false;
     if (ctx.permissionMode === 'always')
         return true;
+    // В режиме «только важное»: MCP — сторонние сайд-эффекты, всегда спрашиваем.
+    if (kind === 'mcp')
+        return true;
     return kind === 'bash' && !!bashCommand && isImportantShellCommand(bashCommand);
 }
 async function askApproval(question, ctx) {
@@ -344,6 +571,60 @@ async function askApproval(question, ctx) {
         rl.close();
     }
 }
+export function matchAndNormalizeEdit(content, oldString, newString) {
+    if (oldString === newString)
+        return { error: 'oldString и newString одинаковые' };
+    // 1. Прямая проверка точного совпадения
+    const directCount = content.split(oldString).length - 1;
+    if (directCount > 0) {
+        return { matchedOld: oldString, matchedNew: newString, occurrences: directCount };
+    }
+    // 2. Нормализация окончаний строк CRLF (\r\n) <-> LF (\n)
+    const isCrlf = content.includes('\r\n');
+    const normContent = content.replace(/\r\n/g, '\n');
+    const normOld = oldString.replace(/\r\n/g, '\n');
+    const normNew = newString.replace(/\r\n/g, '\n');
+    const normCount = normContent.split(normOld).length - 1;
+    if (normCount > 0) {
+        const targetOld = isCrlf ? normOld.replace(/\n/g, '\r\n') : normOld;
+        const targetNew = isCrlf ? normNew.replace(/\n/g, '\r\n') : normNew;
+        const targetCount = content.split(targetOld).length - 1;
+        if (targetCount > 0) {
+            return { matchedOld: targetOld, matchedNew: targetNew, occurrences: targetCount };
+        }
+    }
+    // 3. Нечувствительность к хвостовым пробелам в строках (trailing whitespace)
+    const stripTrailing = (s) => s.split('\n').map(l => l.trimEnd()).join('\n');
+    const strippedNormOld = stripTrailing(normOld);
+    const strippedNormContent = stripTrailing(normContent);
+    if (strippedNormContent.includes(strippedNormOld)) {
+        const contentLines = normContent.split('\n');
+        const oldLines = normOld.split('\n');
+        const matches = [];
+        for (let i = 0; i <= contentLines.length - oldLines.length; i += 1) {
+            let matched = true;
+            for (let j = 0; j < oldLines.length; j += 1) {
+                if (contentLines[i + j].trimEnd() !== oldLines[j].trimEnd()) {
+                    matched = false;
+                    break;
+                }
+            }
+            if (matched) {
+                const rawSlice = contentLines.slice(i, i + oldLines.length).join(isCrlf ? '\r\n' : '\n');
+                matches.push(rawSlice);
+            }
+        }
+        if (matches.length > 0) {
+            const first = matches[0];
+            const targetNew = isCrlf ? normNew.replace(/\n/g, '\r\n') : normNew;
+            const exactCount = content.split(first).length - 1;
+            if (exactCount > 0) {
+                return { matchedOld: first, matchedNew: targetNew, occurrences: exactCount };
+            }
+        }
+    }
+    return { error: 'oldString не найден' };
+}
 function toolEdit(ctx, args) {
     const abs = resolveInCwd(ctx, String(args.path ?? ''));
     const oldString = typeof args.oldString === 'string' ? args.oldString : null;
@@ -360,23 +641,22 @@ function toolEdit(ctx, args) {
     }
     if (!ctx.readFiles.has(abs))
         return Promise.resolve('ошибка: сначала прочитайте файл инструментом read');
-    if (oldString === newString)
-        return Promise.resolve('ошибка: oldString и newString одинаковые');
+    const matchRes = matchAndNormalizeEdit(content, oldString, newString);
+    if ('error' in matchRes)
+        return Promise.resolve(`ошибка: ${matchRes.error}`);
+    const { matchedOld, matchedNew, occurrences } = matchRes;
     const replaceAll = args.replaceAll === true;
-    const occurrences = content.split(oldString).length - 1;
-    if (occurrences === 0)
-        return Promise.resolve('ошибка: oldString не найден');
     if (occurrences > 1 && !replaceAll) {
         return Promise.resolve(`ошибка: найдено совпадений: ${occurrences}, уточните контекст или используйте replaceAll`);
     }
-    const at = content.indexOf(oldString);
+    const at = content.indexOf(matchedOld);
     const before = content.slice(0, at).split('\n');
     const startLine = Math.max(0, before.length - 4);
-    const oldBlock = oldString.split('\n');
-    const newBlock = newString.split('\n');
+    const oldBlock = matchedOld.split('\n');
+    const newBlock = matchedNew.split('\n');
     const preview = diffPreview(content.split('\n'), startLine, oldBlock, newBlock);
     const apply = () => {
-        const next = replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
+        const next = replaceAll ? content.split(matchedOld).join(matchedNew) : content.replace(matchedOld, matchedNew);
         fs.writeFileSync(abs, next);
         ctx.readFiles.add(abs);
         return `готово: заменено ${replaceAll ? occurrences : 1} в ${path.relative(ctx.cwd, abs)}`;
@@ -432,8 +712,21 @@ function toolBash(ctx, args) {
             return Promise.resolve(`ошибка: ${err.message}`);
         }
     }
+    const { shell } = resolveShell(ctx.shell);
     const run = () => new Promise(resolve => {
-        exec(command, { cwd: workdir, timeout, maxBuffer: 1024 * 1024, windowsHide: true }, (err, stdout, stderr) => {
+        let killed = false;
+        const child = exec(command, {
+            cwd: workdir,
+            timeout,
+            maxBuffer: 1024 * 1024,
+            windowsHide: true,
+            shell,
+            env: { ...process.env },
+        }, (err, stdout, stderr) => {
+            if (killed) {
+                resolve('команда прервана пользователем (Ctrl+C)');
+                return;
+            }
             const out = `${stdout || ''}${stderr ? `\n[stderr]\n${stderr}` : ''}`.trim().slice(0, 30000);
             if (err) {
                 const code = err.code;
@@ -443,6 +736,26 @@ function toolBash(ctx, args) {
                 resolve(out || '(пустой вывод)');
             }
         });
+        if (ctx.abortSignal) {
+            const onAbort = () => {
+                killed = true;
+                try {
+                    if (process.platform === 'win32' && child.pid) {
+                        exec(`taskkill /pid ${child.pid} /T /F`, { windowsHide: true }, () => { });
+                    }
+                    else {
+                        child.kill('SIGINT');
+                    }
+                }
+                catch { /* ignore */ }
+            };
+            if (ctx.abortSignal.aborted) {
+                onAbort();
+            }
+            else {
+                ctx.abortSignal.addEventListener('abort', onAbort, { once: true });
+            }
+        }
     });
     if (!requiresApproval(ctx, 'bash', command))
         return run();
@@ -472,6 +785,14 @@ export async function executeAgentTool(ctx, call) {
         return 'ошибка: arguments не JSON';
     }
     try {
+        if (call.name === 'skill')
+            return truncateResult(toolSkill(ctx, args));
+        if (call.name.startsWith('mcp__')) {
+            const split = splitMcpName(call.name);
+            if (!split)
+                return `ошибка: неверное имя MCP-инструмента ${call.name}`;
+            return truncateResult(await toolMcpCall(ctx, split.server, split.tool, args));
+        }
         switch (call.name) {
             case 'read': return truncateResult(toolRead(ctx, args));
             case 'glob': return truncateResult(toolGlob(ctx, args));
@@ -479,7 +800,6 @@ export async function executeAgentTool(ctx, call) {
             case 'edit': return truncateResult(await toolEdit(ctx, args));
             case 'write': return truncateResult(await toolWrite(ctx, args));
             case 'bash': return truncateResult(await toolBash(ctx, args));
-            case 'skill': return truncateResult(toolSkill(ctx, args));
             default: return `ошибка: неизвестный инструмент ${call.name}`;
         }
     }