cli-surf 0.11.0 → 0.12.1

package/cliMcp.js

@@ -0,0 +1,553 @@
+/**
+ * MCP-клиент для surf — как в Codex / Claude Code, без внешних зависимостей.
+ * Транспорт stdio (npx-команды и локальные серверы): JSON-RPC поверх stdin/stdout
+ * дочернего процесса (initialize → tools/list → tools/call).
+ *
+ * Конфиг:
+ *   ~/.surf-cli/mcp.json          — пользовательский уровень
+ *   <cwd>/.surf/mcp.json          — уровень проекта (перекрывает)
+ * Формат: { "mcpServers": { "<name>": { command, args?, env?, cwd?, timeout? } } }
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+export function userMcpPath() {
+    return path.join(os.homedir(), '.surf-cli', 'mcp.json');
+}
+export function projectMcpPath(cwd) {
+    return path.join(path.resolve(cwd), '.surf', 'mcp.json');
+}
+export function validMcpName(name) {
+    return /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(name);
+}
+export function sanitizeServerConfig(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const rec = raw;
+    const hasCommand = typeof rec.command === 'string' && rec.command.trim().length > 0;
+    const hasUrl = typeof rec.url === 'string' && /^https?:\/\/.+/i.test(rec.url.trim());
+    if (!hasCommand && !hasUrl)
+        return null;
+    const cfg = {};
+    if (hasCommand) {
+        cfg.command = rec.command.trim();
+        if (rec.args !== undefined) {
+            if (!Array.isArray(rec.args) || !rec.args.every(a => typeof a === 'string'))
+                return null;
+            cfg.args = rec.args;
+        }
+        if (rec.env !== undefined) {
+            if (!rec.env || typeof rec.env !== 'object' || Array.isArray(rec.env))
+                return null;
+            const env = {};
+            for (const [k, v] of Object.entries(rec.env)) {
+                if (typeof v !== 'string')
+                    return null;
+                env[k] = v;
+            }
+            cfg.env = env;
+        }
+        if (rec.cwd !== undefined) {
+            if (typeof rec.cwd !== 'string' || !rec.cwd.trim())
+                return null;
+            cfg.cwd = rec.cwd;
+        }
+    }
+    if (hasUrl) {
+        cfg.url = rec.url.trim();
+        if (rec.headers !== undefined) {
+            if (!rec.headers || typeof rec.headers !== 'object' || Array.isArray(rec.headers))
+                return null;
+            const headers = {};
+            for (const [k, v] of Object.entries(rec.headers)) {
+                if (typeof v !== 'string')
+                    return null;
+                headers[k] = v;
+            }
+            cfg.headers = headers;
+        }
+    }
+    if (rec.timeout !== undefined) {
+        const t = Number(rec.timeout);
+        if (!Number.isFinite(t))
+            return null;
+        cfg.timeout = Math.min(600000, Math.max(1000, Math.floor(t)));
+    }
+    return cfg;
+}
+/** Читать один конфиг-файл. Возвращает пары + число битых записей. */
+export function loadMcpFile(filePath) {
+    const out = {};
+    let invalid = 0;
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return { servers: out, invalid: 0 };
+    }
+    const section = (raw && typeof raw === 'object' ? raw.mcpServers : null) ?? raw;
+    if (!section || typeof section !== 'object' || Array.isArray(section))
+        return { servers: out, invalid: 0 };
+    for (const [name, cfg] of Object.entries(section)) {
+        const clean = sanitizeServerConfig(cfg);
+        if (!validMcpName(name) || !clean) {
+            invalid += 1;
+            continue;
+        }
+        out[name] = clean;
+    }
+    return { servers: out, invalid };
+}
+/** Мёрдж user + project (project побеждает). */
+export function loadMcpConfig(cwd) {
+    const user = loadMcpFile(userMcpPath());
+    const project = loadMcpFile(projectMcpPath(cwd));
+    return { servers: { ...user.servers, ...project.servers }, invalid: user.invalid + project.invalid };
+}
+export function writeMcpServer(filePath, name, cfg) {
+    let doc = {};
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            doc = parsed;
+    }
+    catch { /* новый файл */ }
+    const section = (doc.mcpServers && typeof doc.mcpServers === 'object' && !Array.isArray(doc.mcpServers)
+        ? doc.mcpServers
+        : {});
+    section[name] = cfg;
+    doc = { ...doc, mcpServers: section };
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(doc, null, 2)}\n`);
+}
+export function removeMcpServer(filePath, name) {
+    let doc;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return false;
+        doc = parsed;
+    }
+    catch {
+        return false;
+    }
+    const section = doc.mcpServers;
+    if (!section || typeof section !== 'object' || Array.isArray(section))
+        return false;
+    const rec = section;
+    if (!(name in rec))
+        return false;
+    delete rec[name];
+    fs.writeFileSync(filePath, `${JSON.stringify(doc, null, 2)}\n`);
+    return true;
+}
+/** Подключиться к удалённому MCP-серверу по SSE / HTTP, вернуть клиент с инструментами. */
+export async function connectMcpSseServer(name, cfg, connectTimeoutMs = 30000) {
+    const url = cfg.url;
+    if (!url)
+        throw new Error(`MCP-сервер ${name} не содержит url`);
+    const abortCtrl = new AbortController();
+    const sseHeaders = {
+        Accept: 'text/event-stream',
+        ...(cfg.headers ?? {}),
+    };
+    let sseRes;
+    try {
+        sseRes = await fetch(url, {
+            headers: sseHeaders,
+            signal: abortCtrl.signal,
+        });
+    }
+    catch (err) {
+        throw new Error(`Ошибка подключения к MCP SSE ${name}: ${err.message}`);
+    }
+    if (!sseRes.ok || !sseRes.body) {
+        throw new Error(`MCP SSE ${name} вернул статус ${sseRes.status}: ${sseRes.statusText}`);
+    }
+    let postEndpoint = url;
+    let endpointResolved = false;
+    const endpointWaiters = [];
+    const pending = new Map();
+    let nextId = 1;
+    const reader = sseRes.body.getReader();
+    const decoder = new TextDecoder();
+    let carry = '';
+    const processEvent = (eventBlock) => {
+        const lines = eventBlock.split(/\r?\n/);
+        let eventType = 'message';
+        const dataLines = [];
+        for (const line of lines) {
+            if (line.startsWith('event:')) {
+                eventType = line.slice(6).trim();
+            }
+            else if (line.startsWith('data:')) {
+                dataLines.push(line.slice(5).trim());
+            }
+        }
+        const dataText = dataLines.join('\n').trim();
+        if (!dataText)
+            return;
+        if (eventType === 'endpoint') {
+            try {
+                postEndpoint = new URL(dataText, url).toString();
+            }
+            catch {
+                postEndpoint = dataText;
+            }
+            endpointResolved = true;
+            for (const w of endpointWaiters)
+                w(postEndpoint);
+            endpointWaiters.length = 0;
+            return;
+        }
+        let msg = null;
+        try {
+            msg = JSON.parse(dataText);
+        }
+        catch {
+            return;
+        }
+        if (!msg || typeof msg !== 'object' || msg.jsonrpc !== '2.0')
+            return;
+        if (typeof msg.id === 'number' || typeof msg.id === 'string') {
+            const entry = pending.get(msg.id);
+            if (entry) {
+                pending.delete(msg.id);
+                clearTimeout(entry.timer);
+                if (msg.error) {
+                    entry.reject(new Error(typeof msg.error.message === 'string' ? msg.error.message : 'MCP error'));
+                }
+                else {
+                    entry.resolve(msg.result);
+                }
+            }
+        }
+    };
+    void (async () => {
+        try {
+            for (;;) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                carry += decoder.decode(value, { stream: true });
+                const blocks = carry.split(/\r?\n\r?\n/);
+                carry = blocks.pop() ?? '';
+                for (const block of blocks) {
+                    if (block.trim())
+                        processEvent(block);
+                }
+            }
+        }
+        catch {
+            /* поток закрыт или прерван */
+        }
+        finally {
+            for (const [, entry] of pending) {
+                clearTimeout(entry.timer);
+                entry.reject(new Error(`MCP SSE поток закрыт`));
+            }
+            pending.clear();
+        }
+    })();
+    const waitForEndpoint = () => {
+        if (endpointResolved)
+            return Promise.resolve(postEndpoint);
+        return new Promise(resolve => {
+            const t = setTimeout(() => {
+                resolve(postEndpoint);
+            }, 1500);
+            endpointWaiters.push((resolvedUrl) => {
+                clearTimeout(t);
+                resolve(resolvedUrl);
+            });
+        });
+    };
+    await waitForEndpoint();
+    const sendPost = async (msg) => {
+        return fetch(postEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/event-stream',
+                ...(cfg.headers ?? {}),
+            },
+            body: JSON.stringify(msg),
+            signal: abortCtrl.signal,
+        });
+    };
+    const request = (method, params, timeoutMs) => new Promise((res, rej) => {
+        const id = nextId;
+        nextId += 1;
+        const timer = setTimeout(() => {
+            pending.delete(id);
+            rej(new Error(`MCP timeout: ${method}`));
+        }, timeoutMs);
+        pending.set(id, { resolve: res, reject: rej, timer });
+        sendPost({ jsonrpc: '2.0', id, method, params }).then(async (httpRes) => {
+            if (!httpRes.ok) {
+                const errText = await httpRes.text().catch(() => '');
+                const entry = pending.get(id);
+                if (entry) {
+                    pending.delete(id);
+                    clearTimeout(entry.timer);
+                    entry.reject(new Error(`MCP POST HTTP ${httpRes.status}: ${errText || httpRes.statusText}`));
+                }
+                return;
+            }
+            const ctype = httpRes.headers.get('content-type') || '';
+            if (ctype.includes('application/json')) {
+                try {
+                    const json = await httpRes.json();
+                    if (json && json.jsonrpc === '2.0' && json.id === id) {
+                        const entry = pending.get(id);
+                        if (entry) {
+                            pending.delete(id);
+                            clearTimeout(entry.timer);
+                            if (json.error)
+                                entry.reject(new Error(typeof json.error.message === 'string' ? json.error.message : 'MCP error'));
+                            else
+                                entry.resolve(json.result);
+                        }
+                    }
+                }
+                catch { /* ответ может поступить через SSE */ }
+            }
+        }).catch(err => {
+            const entry = pending.get(id);
+            if (entry) {
+                pending.delete(id);
+                clearTimeout(entry.timer);
+                entry.reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    });
+    const sendNotification = (method, params) => {
+        void sendPost({ jsonrpc: '2.0', method, ...(params ? { params } : {}) }).catch(() => { });
+    };
+    const tools = [];
+    try {
+        await request('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'surf', version: '0.12.0' },
+        }, connectTimeoutMs);
+        sendNotification('notifications/initialized');
+        const listed = await request('tools/list', {}, connectTimeoutMs);
+        const rawTools = Array.isArray(listed?.tools)
+            ? listed.tools
+            : [];
+        for (const t of rawTools) {
+            if (!t || typeof t !== 'object')
+                continue;
+            const rec = t;
+            if (typeof rec.name !== 'string' || !rec.name)
+                continue;
+            const schema = rec.inputSchema && typeof rec.inputSchema === 'object' && !Array.isArray(rec.inputSchema)
+                ? rec.inputSchema
+                : { type: 'object' };
+            tools.push({
+                server: name,
+                name: rec.name,
+                description: typeof rec.description === 'string' ? rec.description.slice(0, 1000) : '',
+                inputSchema: schema,
+            });
+        }
+    }
+    catch (err) {
+        try {
+            abortCtrl.abort();
+        }
+        catch { /* ignore */ }
+        throw err;
+    }
+    const client = {
+        name,
+        tools,
+        call: async (toolName, args, timeoutMs) => {
+            const res = await request('tools/call', { name: toolName, arguments: args ?? {} }, timeoutMs);
+            const parts = Array.isArray(res?.content) ? res.content : [];
+            const texts = parts
+                .filter(p => p && typeof p === 'object' && p.type === 'text' && typeof p.text === 'string')
+                .map(p => p.text);
+            const nonText = parts.length - texts.length;
+            const suffix = nonText > 0 ? `\n[ещё ${nonText} не-текстовых частей пропущено]` : '';
+            const out = `${texts.join('\n')}${suffix}`.trim();
+            if (res?.isError)
+                throw new Error(out || 'MCP-инструмент вернул ошибку');
+            return out || '(пустой результат)';
+        },
+        close: () => {
+            try {
+                abortCtrl.abort();
+            }
+            catch { /* ignore */ }
+        },
+    };
+    return client;
+}
+/** Подключиться к MCP-серверу по stdio, вернуть клиент с инструментами. */
+export function connectMcpStdioServer(name, cfg, connectTimeoutMs = 30000) {
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn(cfg.command || '', cfg.args ?? [], {
+                env: { ...process.env, ...(cfg.env ?? {}) },
+                cwd: cfg.cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: true,
+            });
+        }
+        catch (err) {
+            reject(err instanceof Error ? err : new Error(String(err)));
+            return;
+        }
+        let settled = false;
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                child.kill();
+            }
+            catch { /* ignore */ }
+            reject(err);
+        };
+        child.on('error', err => fail(err instanceof Error ? err : new Error(String(err))));
+        const stderr = child.stderr;
+        if (stderr)
+            stderr.on('data', () => { });
+        const pending = new Map();
+        let nextId = 1;
+        let carry = '';
+        const stdin = child.stdin;
+        if (!stdin || !child.stdout) {
+            fail(new Error('stdio недоступен'));
+            return;
+        }
+        const send = (msg) => {
+            stdin.write(`${JSON.stringify(msg)}\n`);
+        };
+        const request = (method, params, timeoutMs) => new Promise((res, rej) => {
+            const id = nextId;
+            nextId += 1;
+            const timer = setTimeout(() => {
+                pending.delete(id);
+                rej(new Error(`MCP timeout: ${method}`));
+            }, timeoutMs);
+            pending.set(id, { resolve: res, reject: rej, timer });
+            send({ jsonrpc: '2.0', id, method, params });
+        });
+        child.stdout.on('data', (chunk) => {
+            carry += chunk.toString('utf8');
+            const lines = carry.split('\n');
+            carry = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                let msg;
+                try {
+                    msg = JSON.parse(trimmed);
+                }
+                catch {
+                    continue; // логи сервера в stdout — игнорим
+                }
+                if (!msg || typeof msg !== 'object' || msg.jsonrpc !== '2.0')
+                    continue;
+                if (typeof msg.id === 'number' || typeof msg.id === 'string') {
+                    const entry = pending.get(msg.id);
+                    if (!entry)
+                        continue;
+                    pending.delete(msg.id);
+                    clearTimeout(entry.timer);
+                    if (msg.error)
+                        entry.reject(new Error(typeof msg.error.message === 'string' ? msg.error.message : 'MCP error'));
+                    else
+                        entry.resolve(msg.result);
+                }
+                // уведомления от сервера игнорим
+            }
+        });
+        child.on('exit', (code) => {
+            for (const [, entry] of pending) {
+                clearTimeout(entry.timer);
+                entry.reject(new Error(`MCP-сервер завершился (code ${code ?? '?'})`));
+            }
+            pending.clear();
+            if (!settled)
+                fail(new Error(`MCP-сервер завершился до handshake (code ${code ?? '?'})`));
+        });
+        const tools = [];
+        const doHandshake = async () => {
+            const init = await request('initialize', {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'surf', version: '0.12.0' },
+            }, connectTimeoutMs);
+            void init;
+            send({ jsonrpc: '2.0', method: 'notifications/initialized' });
+            const listed = await request('tools/list', {}, connectTimeoutMs);
+            const rawTools = Array.isArray(listed?.tools)
+                ? listed.tools
+                : [];
+            for (const t of rawTools) {
+                if (!t || typeof t !== 'object')
+                    continue;
+                const rec = t;
+                if (typeof rec.name !== 'string' || !rec.name)
+                    continue;
+                const schema = rec.inputSchema && typeof rec.inputSchema === 'object' && !Array.isArray(rec.inputSchema)
+                    ? rec.inputSchema
+                    : { type: 'object' };
+                tools.push({
+                    server: name,
+                    name: rec.name,
+                    description: typeof rec.description === 'string' ? rec.description.slice(0, 1000) : '',
+                    inputSchema: schema,
+                });
+            }
+            const client = {
+                name,
+                tools,
+                call: async (toolName, args, timeoutMs) => {
+                    const res = await request('tools/call', { name: toolName, arguments: args ?? {} }, timeoutMs);
+                    const parts = Array.isArray(res?.content) ? res.content : [];
+                    const texts = parts
+                        .filter(p => p && typeof p === 'object' && p.type === 'text' && typeof p.text === 'string')
+                        .map(p => p.text);
+                    const nonText = parts.length - texts.length;
+                    const suffix = nonText > 0 ? `\n[ещё ${nonText} не-текстовых частей пропущено]` : '';
+                    const out = `${texts.join('\n')}${suffix}`.trim();
+                    if (res?.isError)
+                        throw new Error(out || 'MCP-инструмент вернул ошибку');
+                    return out || '(пустой результат)';
+                },
+                close: () => {
+                    try {
+                        child.kill();
+                    }
+                    catch { /* ignore */ }
+                },
+            };
+            return client;
+        };
+        doHandshake().then(client => {
+            if (settled) {
+                client.close();
+                return;
+            }
+            settled = true;
+            resolve(client);
+        }, err => fail(err instanceof Error ? err : new Error(String(err))));
+    });
+}
+/** Подключиться к MCP-серверу (stdio или SSE), вернуть клиент с инструментами. */
+export function connectMcpServer(name, cfg, connectTimeoutMs = 30000) {
+    if (cfg.url) {
+        return connectMcpSseServer(name, cfg, connectTimeoutMs);
+    }
+    return connectMcpStdioServer(name, cfg, connectTimeoutMs);
+}
+//# sourceMappingURL=cliMcp.js.map