blyuecode 0.1.16 → 0.2.0

package/dist/core/mcp.js

@@ -0,0 +1,333 @@
+// Minimal MCP client — stdio + HTTP/SSE transports, JSON-RPC 2.0.
+// Spec: https://spec.modelcontextprotocol.io/
+//
+// No external dependencies. Uses Node 20's global fetch for SSE.
+//
+// Usage:
+//   const client = new McpClient(name, config);
+//   await client.connect();
+//   const tools = await client.listTools();
+//   const result = await client.callTool('read_file', { path: '...' });
+//   await client.close();
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+// ──────────────────────────────────────────────────────────────
+// Stdio transport — newline-delimited JSON-RPC over child stdin/stdout
+// ──────────────────────────────────────────────────────────────
+class StdioTransport extends EventEmitter {
+    proc;
+    buf = '';
+    lastStderr = '';
+    get stderrTail() { return this.lastStderr; }
+    constructor(cfg) {
+        super();
+        this.proc = spawn(cfg.command, cfg.args ?? [], {
+            cwd: cfg.cwd,
+            env: { ...process.env, ...(cfg.env ?? {}) },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.proc.stdout?.on('data', (chunk) => {
+            this.buf += chunk.toString('utf8');
+            let idx;
+            while ((idx = this.buf.indexOf('\n')) >= 0) {
+                const line = this.buf.slice(0, idx).trim();
+                this.buf = this.buf.slice(idx + 1);
+                if (!line)
+                    continue;
+                try {
+                    const msg = JSON.parse(line);
+                    this.emit('message', msg);
+                }
+                catch {
+                    // Not JSON — ignore (some servers log to stdout, which is rude
+                    // but happens; stderr is the correct channel for logs).
+                }
+            }
+        });
+        this.proc.stderr?.on('data', (chunk) => {
+            // Servers log readiness banners and diagnostics to stderr — that's
+            // the MCP spec's designated log channel. Never treat stderr as an
+            // error: it would kill the in-flight initialize request. Keep the
+            // last few KB around for debugging, but do nothing else with it.
+            this.lastStderr = (this.lastStderr + chunk.toString('utf8')).slice(-4096);
+        });
+        this.proc.on('error', (err) => this.emit('error', err));
+        this.proc.on('exit', () => this.emit('close'));
+    }
+    send(msg) {
+        if (!this.proc.stdin || this.proc.stdin.destroyed) {
+            throw new Error('stdio transport closed');
+        }
+        this.proc.stdin.write(JSON.stringify(msg) + '\n');
+    }
+    close() {
+        try {
+            this.proc.stdin?.end();
+            this.proc.kill('SIGTERM');
+            // SIGKILL fallback if it doesn't die within 2s.
+            setTimeout(() => {
+                if (this.proc.exitCode === null)
+                    this.proc.kill('SIGKILL');
+            }, 2000).unref?.();
+        }
+        catch {
+            // already dead
+        }
+    }
+}
+// ──────────────────────────────────────────────────────────────
+// SSE transport — POST for sends, GET text/event-stream for receives
+//
+// MCP's HTTP+SSE transport (2024-11-05 spec):
+//   1. GET url -> text/event-stream, server sends an `endpoint` event
+//      with the POST URL to use for requests.
+//   2. POST JSON-RPC requests to that endpoint; responses come back on
+//      the SSE stream as `message` events.
+// ──────────────────────────────────────────────────────────────
+class SseTransport extends EventEmitter {
+    cfg;
+    postUrl = null;
+    abort = null;
+    closed = false;
+    constructor(cfg) {
+        super();
+        this.cfg = cfg;
+        void this.start();
+    }
+    async start() {
+        try {
+            this.abort = new AbortController();
+            const res = await fetch(this.cfg.url, {
+                headers: {
+                    Accept: 'text/event-stream',
+                    ...(this.cfg.headers ?? {}),
+                },
+                signal: this.abort.signal,
+            });
+            if (!res.ok || !res.body) {
+                throw new Error(`SSE connect failed: HTTP ${res.status}`);
+            }
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buf = '';
+            while (!this.closed) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true });
+                let idx;
+                while ((idx = buf.indexOf('\n\n')) >= 0) {
+                    const rawEvent = buf.slice(0, idx);
+                    buf = buf.slice(idx + 2);
+                    this.parseEvent(rawEvent);
+                }
+            }
+            this.emit('close');
+        }
+        catch (err) {
+            if (!this.closed)
+                this.emit('error', err);
+        }
+    }
+    parseEvent(raw) {
+        let event = 'message';
+        let data = '';
+        for (const line of raw.split('\n')) {
+            if (line.startsWith('event:'))
+                event = line.slice(6).trim();
+            else if (line.startsWith('data:'))
+                data += line.slice(5).trim();
+        }
+        if (!data)
+            return;
+        if (event === 'endpoint') {
+            // Server tells us where to POST. Relative URLs are resolved against
+            // the SSE endpoint's origin.
+            try {
+                this.postUrl = new URL(data, this.cfg.url).toString();
+            }
+            catch {
+                this.postUrl = data;
+            }
+            return;
+        }
+        if (event === 'message') {
+            try {
+                const msg = JSON.parse(data);
+                this.emit('message', msg);
+            }
+            catch {
+                // ignore malformed
+            }
+        }
+    }
+    send(msg) {
+        if (!this.postUrl) {
+            throw new Error('SSE transport not ready — no endpoint event received yet');
+        }
+        void fetch(this.postUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.cfg.headers ?? {}),
+            },
+            body: JSON.stringify(msg),
+        }).catch((err) => this.emit('error', err));
+    }
+    close() {
+        this.closed = true;
+        this.abort?.abort();
+    }
+}
+// ──────────────────────────────────────────────────────────────
+// Client
+// ──────────────────────────────────────────────────────────────
+export class McpClient {
+    name;
+    cfg;
+    transport = null;
+    nextId = 1;
+    pending = new Map();
+    connected = false;
+    serverInfo = null;
+    cachedTools = null;
+    constructor(name, cfg) {
+        this.name = name;
+        this.cfg = cfg;
+    }
+    get autoAllow() {
+        return this.cfg.autoAllow === true;
+    }
+    get info() {
+        return this.serverInfo;
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        this.transport =
+            'command' in this.cfg
+                ? new StdioTransport(this.cfg)
+                : new SseTransport(this.cfg);
+        this.transport.on('message', (msg) => this.handleMessage(msg));
+        this.transport.on('error', (err) => {
+            // Route transport errors to any in-flight request so they don't hang.
+            for (const [, p] of this.pending) {
+                clearTimeout(p.timer);
+                p.reject(err);
+            }
+            this.pending.clear();
+        });
+        this.transport.on('close', () => {
+            this.connected = false;
+        });
+        // Handshake
+        const result = (await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: { tools: {} },
+            clientInfo: { name: 'blyue', version: '0.2.0' },
+        }));
+        this.serverInfo = result?.serverInfo ?? null;
+        // Spec requires this notification after initialize.
+        this.notify('notifications/initialized', {});
+        this.connected = true;
+    }
+    async listTools() {
+        if (this.cachedTools)
+            return this.cachedTools;
+        const res = (await this.request('tools/list', {}));
+        this.cachedTools = res?.tools ?? [];
+        return this.cachedTools;
+    }
+    async callTool(name, args) {
+        const res = (await this.request('tools/call', {
+            name,
+            arguments: args,
+        }));
+        return res;
+    }
+    async close() {
+        for (const [, p] of this.pending) {
+            clearTimeout(p.timer);
+            p.reject(new Error('client closed'));
+        }
+        this.pending.clear();
+        this.transport?.close();
+        this.transport = null;
+        this.connected = false;
+        this.cachedTools = null;
+    }
+    // ────────────────────────────────────────────
+    handleMessage(msg) {
+        if ('id' in msg && msg.id !== undefined) {
+            const p = this.pending.get(msg.id);
+            if (!p)
+                return;
+            this.pending.delete(msg.id);
+            clearTimeout(p.timer);
+            if (msg.error) {
+                p.reject(new Error(`${msg.error.code}: ${msg.error.message}`));
+            }
+            else {
+                p.resolve(msg.result);
+            }
+            return;
+        }
+        // Notifications from server (e.g. tools/list_changed) — currently ignored.
+    }
+    request(method, params) {
+        if (!this.transport)
+            throw new Error('not connected');
+        const id = this.nextId++;
+        const timeoutMs = ('timeoutMs' in this.cfg ? this.cfg.timeoutMs : undefined) ?? 60_000;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP request "${method}" timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.transport.send({ jsonrpc: '2.0', id, method, params });
+            }
+            catch (err) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(err);
+            }
+        });
+    }
+    notify(method, params) {
+        if (!this.transport)
+            return;
+        this.transport.send({ jsonrpc: '2.0', method, params });
+    }
+}
+// ──────────────────────────────────────────────────────────────
+// Config load / save
+// ──────────────────────────────────────────────────────────────
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+export function mcpConfigPath() {
+    return join(homedir(), '.blyue', 'mcp.json');
+}
+export function loadMcpConfig() {
+    const p = mcpConfigPath();
+    if (!existsSync(p))
+        return { servers: {} };
+    try {
+        const raw = readFileSync(p, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.servers || typeof parsed.servers !== 'object') {
+            return { servers: {} };
+        }
+        return parsed;
+    }
+    catch (err) {
+        throw new Error(`Failed to parse ${p}: ${err.message}`);
+    }
+}
+export function saveMcpConfig(cfg) {
+    const p = mcpConfigPath();
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+}

package/dist/core/mcpRegistry.js

@@ -0,0 +1,188 @@
+// MCP registry — holds all connected MCP clients as a module-level
+// singleton so the tools layer can merge their tool defs into the LLM's
+// tool list without threading state through the agent.
+//
+// Lifecycle:
+//   1. index.tsx calls initMcpRegistry() once after config load
+//   2. tools.ts calls getMcpToolDefsSync() every agent-loop iteration
+//   3. agent calls executeTool() → falls through to executeMcpTool()
+//      for names prefixed mcp__<server>__<tool>
+import { McpClient, loadMcpConfig, } from './mcp.js';
+import { permissions } from './permission.js';
+const servers = new Map();
+let cachedDefs = [];
+let initPromise = null;
+let initialized = false;
+/**
+ * Called once on app startup, after config is loaded.
+ * Never throws — a bad MCP server is logged and skipped so the TUI
+ * still boots. (Failing closed here would make a typo in mcp.json
+ * brick the whole app.)
+ */
+export async function initMcpRegistry() {
+    if (initPromise)
+        return initPromise;
+    initPromise = (async () => {
+        let cfg;
+        try {
+            cfg = loadMcpConfig();
+        }
+        catch {
+            initialized = true;
+            return;
+        }
+        const entries = Object.entries(cfg.servers || {});
+        if (entries.length === 0) {
+            initialized = true;
+            return;
+        }
+        await Promise.all(entries.map(async ([name, serverCfg]) => {
+            const client = new McpClient(name, serverCfg);
+            try {
+                await client.connect();
+                const tools = await client.listTools();
+                servers.set(name, { client, tools });
+            }
+            catch (err) {
+                servers.set(name, {
+                    client,
+                    tools: [],
+                    error: err.message,
+                });
+                try {
+                    await client.close();
+                }
+                catch { }
+            }
+        }));
+        rebuildDefs();
+        initialized = true;
+    })();
+    return initPromise;
+}
+function rebuildDefs() {
+    const defs = [];
+    for (const [serverName, state] of servers) {
+        if (state.error)
+            continue;
+        for (const t of state.tools) {
+            defs.push({
+                type: 'function',
+                function: {
+                    name: `mcp__${serverName}__${t.name}`,
+                    description: t.description ||
+                        `MCP tool "${t.name}" from server "${serverName}".`,
+                    parameters: t.schema || { type: 'object', properties: {} },
+                },
+            });
+        }
+    }
+    cachedDefs = defs;
+}
+/** Synchronous — safe to call every iteration of the agent loop. */
+export function getMcpToolDefsSync() {
+    return cachedDefs;
+}
+export function isMcpTool(name) {
+    return typeof name === 'string' && name.startsWith('mcp__');
+}
+export function parseMcpToolName(fullName) {
+    if (!isMcpTool(fullName))
+        return null;
+    const rest = fullName.slice('mcp__'.length);
+    const idx = rest.indexOf('__');
+    if (idx < 0)
+        return null;
+    return { server: rest.slice(0, idx), tool: rest.slice(idx + 2) };
+}
+/**
+ * Executes an MCP tool call. Routes through the permission broker
+ * unless the server is marked autoAllow:true in mcp.json.
+ */
+export async function executeMcpTool(fullName, args) {
+    const parsed = parseMcpToolName(fullName);
+    if (!parsed)
+        return `Error: not an MCP tool: ${fullName}`;
+    const state = servers.get(parsed.server);
+    if (!state)
+        return `Error: MCP server "${parsed.server}" not registered`;
+    if (state.error) {
+        return `Error: MCP server "${parsed.server}" failed to connect: ${state.error}`;
+    }
+    const { client } = state;
+    const alreadyAllowed = permissions.isAlwaysAllowed(fullName);
+    if (!client.autoAllow && !alreadyAllowed) {
+        const argSummary = safeJson(args).slice(0, 400);
+        const answer = await permissions.ask({
+            tool: fullName,
+            title: `MCP · ${parsed.server}`,
+            body: [
+                `Tool: ${parsed.tool}`,
+                `Args: ${argSummary || '(none)'}`,
+            ],
+            danger: 'medium',
+        });
+        if (answer === 'no')
+            return `Denied by user: ${fullName}`;
+    }
+    try {
+        const result = await client.callTool(parsed.tool, args || {});
+        return formatResult(result);
+    }
+    catch (err) {
+        return `MCP error: ${err.message}`;
+    }
+}
+function formatResult(result) {
+    if (!result || !Array.isArray(result.content)) {
+        return safeJson(result);
+    }
+    const parts = [];
+    for (const c of result.content) {
+        if (c.type === 'text')
+            parts.push(c.text);
+        else if (c.type === 'image')
+            parts.push(`[image ${c.mimeType}, ${c.data.length} base64 chars]`);
+        else if (c.type === 'resource')
+            parts.push(c.resource.text ??
+                `[resource ${c.resource.uri}${c.resource.blob ? ', blob' : ''}]`);
+    }
+    const text = parts.join('\n');
+    return result.isError ? `ERROR: ${text}` : text;
+}
+function safeJson(v) {
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+export function listMcpServers() {
+    const out = [];
+    for (const [name, state] of servers) {
+        out.push({
+            name,
+            autoAllow: state.client.autoAllow,
+            toolCount: state.tools.length,
+            toolNames: state.tools.map((t) => t.name),
+            error: state.error,
+        });
+    }
+    return out;
+}
+export function isMcpReady() {
+    return initialized;
+}
+export async function closeAllMcp() {
+    for (const [, state] of servers) {
+        try {
+            await state.client.close();
+        }
+        catch { }
+    }
+    servers.clear();
+    cachedDefs = [];
+    initPromise = null;
+    initialized = false;
+}

package/dist/core/tools.js

@@ -5,6 +5,7 @@ import { promisify } from 'util';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { hasN8n } from './config.js';
+import { getMcpToolDefsSync, executeMcpTool, isMcpTool } from './mcpRegistry.js';
 import { permissions } from './permission.js';
 import { lineDiff, compactDiff } from './diff.js';
 import { isBlocked } from './sandbox.js';
@@ -86,7 +87,8 @@ const N8N_TOOLS = [
     { type: 'function', function: { name: 'n8n_deactivate_workflow', description: 'Deactivate n8n workflow', parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } } },
 ];
 export function getToolDefs() {
-    return hasN8n() ? [...BASE_TOOLS, ...N8N_TOOLS] : [...BASE_TOOLS];
+    const base = hasN8n() ? [...BASE_TOOLS, ...N8N_TOOLS] : [...BASE_TOOLS];
+    return [...base, ...getMcpToolDefsSync()];
 }
 export const toolDefs = BASE_TOOLS;
 const DANGER_PATTERNS = [
@@ -242,6 +244,8 @@ export async function executeTool(name, args) {
             case 'n8n_deactivate_workflow':
                 return await n8nDeactivateWorkflow(args.id);
             default:
+                if (isMcpTool(name))
+                    return executeMcpTool(name, args);
                 return 'Unknown tool: ' + name;
         }
     }

package/dist/index.js

@@ -8,6 +8,7 @@ import { Banner } from './ui/Banner.js';
 import { Consent, hasConsented } from './ui/Consent.js';
 import { loadConfig, applyConfig } from './core/config.js';
 import { loadSession } from './core/session.js';
+import { initMcpRegistry } from './core/mcpRegistry.js';
 const App = () => {
     const [ready, setReady] = useState(false);
     const [resumedCount, setResumedCount] = useState(0);
@@ -18,6 +19,7 @@ const App = () => {
         const existing = loadConfig();
         if (existing) {
             applyConfig(existing);
+            void initMcpRegistry();
             const hist = loadSession();
             setResumedCount(hist ? hist.length : 0);
             setReady(true);

package/dist/ui/Settings.js

@@ -92,7 +92,9 @@ export const Settings = ({ onClose, onModelChange }) => {
     const inner = width - 4;
     const top = (label) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '╭─ ' }), _jsx(Text, { color: theme.accent, bold: true, children: label }), _jsx(Text, { color: theme.muted, children: ' ' + '─'.repeat(Math.max(1, inner - label.length - 3)) + '╮' })] }));
     const bot = (_jsx(Text, { color: theme.muted, children: '╰' + '─'.repeat(inner) + '╯' }));
-    const row = (content) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), content] }));
+    // ⚠️  Changed from <Text> to <Box flexDirection="row"> — callers pass a
+    // <Box> containing a prompt + <KeyInput>, and Ink forbids Box-in-Text.
+    const row = (content) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.muted, children: '│ ' }), content] }));
     // ---- Main screen ----
     if (screen === 'main') {
         const baseUrlIsLocal = (cfg.baseUrl || '').includes('localhost') ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blyuecode",
-  "version": "0.1.16",
+  "version": "0.2.0",
   "description": "BLYUE Code — a coding agent by Lumen",
   "type": "module",
   "license": "MIT",