ikie-cli 0.1.32 → 0.1.34

package/dist/mcp-manager.js

@@ -1,353 +1,759 @@
 import { spawn } from 'child_process';
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { HOME_DIR } from './config.js';
-const MCP_REGISTRY_FILE = join(HOME_DIR, 'mcp-registry.json');
-const MCP_DIR = join(HOME_DIR, 'mcps');
-export class MCPManager {
-    registry;
-    processes = new Map();
-    messageHandlers = new Map();
-    constructor() {
-        this.ensureMCPDir();
-        this.registry = this.loadRegistry();
-        this.initializeBuiltInServers();
-    }
-    ensureMCPDir() {
-        if (!existsSync(MCP_DIR)) {
-            mkdirSync(MCP_DIR, { recursive: true });
+import { VERSION } from './theme.js';
+// ─── Config file paths ────────────────────────────────────────────────────────
+const USER_MCP_FILE = join(HOME_DIR, 'mcp.json');
+const OLD_REGISTRY_FILE = join(HOME_DIR, 'mcp-registry.json');
+function projectMcpFile(cwd) {
+    return join(cwd, '.mcp.json');
+}
+function localMcpFile(cwd) {
+    return join(cwd, '.mcp.local.json');
+}
+function ensureUserDir() {
+    if (!existsSync(HOME_DIR))
+        mkdirSync(HOME_DIR, { recursive: true });
+}
+// ─── Pure helpers (exported for tests) ───────────────────────────────────────
+const ENV_VAR_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
+export function expandEnvVars(value, env) {
+    return value.replace(ENV_VAR_RE, (_, name, fallback) => {
+        const v = env[name];
+        if (v === undefined || v === null || v === '')
+            return fallback ?? '';
+        return v;
+    });
+}
+export function expandEnvVarsInEntry(entry, env) {
+    const expand = (s) => expandEnvVars(s, env);
+    const expandRecord = (r) => {
+        if (!r)
+            return undefined;
+        const out = {};
+        for (const [k, v] of Object.entries(r))
+            out[k] = expand(v);
+        return out;
+    };
+    return {
+        ...entry,
+        command: entry.command ? expand(entry.command) : undefined,
+        args: entry.args?.map(expand),
+        env: expandRecord(entry.env),
+        url: entry.url ? expand(entry.url) : undefined,
+        headers: expandRecord(entry.headers),
+    };
+}
+export function inferTransport(entry) {
+    if (entry.type) {
+        const t = entry.type.toLowerCase();
+        if (t === 'http' || t === 'streamable-http' || t === 'sse' || t === 'stdio')
+            return t;
+    }
+    if (entry.command)
+        return 'stdio';
+    if (entry.url)
+        return 'http';
+    return 'stdio';
+}
+export function mergeScopes(local, project, user) {
+    const out = {};
+    for (const scope of [user, project, local]) {
+        if (!scope.mcpServers)
+            continue;
+        for (const [name, entry] of Object.entries(scope.mcpServers)) {
+            out[name] = entry;
         }
     }
-    loadRegistry() {
-        if (existsSync(MCP_REGISTRY_FILE)) {
-            try {
-                return JSON.parse(readFileSync(MCP_REGISTRY_FILE, 'utf-8'));
-            }
-            catch {
-                return { servers: {}, builtIn: [] };
-            }
+    return out;
+}
+const NAME_SANITIZE_RE = /[^A-Za-z0-9_-]+/g;
+export function sanitizeMcpName(s) {
+    return s.replace(NAME_SANITIZE_RE, '_');
+}
+export function mcpToolName(server, tool) {
+    return `mcp__${sanitizeMcpName(server)}__${sanitizeMcpName(tool)}`;
+}
+export function buildReverseToolMap(tools) {
+    const out = new Map();
+    for (const [server, serverTools] of tools) {
+        for (const t of serverTools) {
+            out.set(mcpToolName(server, t.name), { server, tool: t.name });
         }
-        return { servers: {}, builtIn: [] };
-    }
-    saveRegistry() {
-        writeFileSync(MCP_REGISTRY_FILE, JSON.stringify(this.registry, null, 2));
-    }
-    initializeBuiltInServers() {
-        const builtIn = {
-            filesystem: {
-                name: 'filesystem',
-                command: 'node',
-                args: [join(MCP_DIR, 'filesystem-server.js')],
-                description: 'File system operations MCP',
-                enabled: true,
-                autoStart: true,
-            },
-            github: {
-                name: 'github',
-                command: 'node',
-                args: [join(MCP_DIR, 'github-server.js')],
-                env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN || '' },
-                description: 'GitHub API operations MCP',
-                enabled: false,
-                autoStart: false,
-            },
-            database: {
-                name: 'database',
-                command: 'node',
-                args: [join(MCP_DIR, 'database-server.js')],
-                description: 'Database operations MCP (SQLite, PostgreSQL)',
-                enabled: false,
-                autoStart: false,
-            },
-            puppeteer: {
-                name: 'puppeteer',
-                command: 'node',
-                args: [join(MCP_DIR, 'puppeteer-server.js')],
-                description: 'Browser automation MCP',
-                enabled: false,
-                autoStart: false,
-            },
-        };
-        for (const [name, server] of Object.entries(builtIn)) {
-            if (!this.registry.servers[name]) {
-                this.registry.servers[name] = server;
-                if (!this.registry.builtIn.includes(name)) {
-                    this.registry.builtIn.push(name);
-                }
-            }
+    }
+    return out;
+}
+export function parseClaudeMcpAddCommand(str, defaultScope = 'user') {
+    const tokens = tokenizeAddCommand(str);
+    // Find "mcp add" in the token stream; ignore any preceding prefix (e.g. "claude").
+    let idx = 0;
+    while (idx < tokens.length - 1) {
+        if (tokens[idx].toLowerCase() === 'mcp' && tokens[idx + 1].toLowerCase() === 'add') {
+            idx += 2;
+            break;
         }
-        this.saveRegistry();
+        idx++;
     }
-    async installMCP(config) {
-        try {
-            if (this.registry.servers[config.name]) {
-                return { success: false, error: `MCP '${config.name}' already installed` };
-            }
-            let command;
-            let args;
-            if (config.source.startsWith('npm:')) {
-                const pkg = config.source.slice(4);
-                const { execSync } = await import('child_process');
-                execSync(`npm install -g ${pkg}`, { cwd: MCP_DIR });
-                command = 'npx';
-                args = ['-y', pkg];
-            }
-            else if (config.source.startsWith('http://') || config.source.startsWith('https://')) {
-                const { execSync } = await import('child_process');
-                const repoName = config.source.split('/').pop()?.replace('.git', '') || config.name;
-                const repoPath = join(MCP_DIR, repoName);
-                execSync(`git clone ${config.source} ${repoPath}`, { cwd: MCP_DIR });
-                execSync('npm install', { cwd: repoPath });
-                command = 'node';
-                args = [join(repoPath, 'index.js')];
-            }
-            else {
-                command = 'node';
-                args = [config.source];
+    if (idx >= tokens.length)
+        return { error: 'Missing "mcp add" in command' };
+    let scope = defaultScope;
+    let scopeExplicit = false;
+    let transport;
+    const env = {};
+    const headers = {};
+    let i = idx;
+    while (i < tokens.length && tokens[i].startsWith('--')) {
+        const flag = tokens[i];
+        if (flag === '--scope') {
+            const v = tokens[++i];
+            if (v === 'user' || v === 'project' || v === 'local') {
+                scope = v;
+                scopeExplicit = true;
             }
-            const server = {
-                name: config.name,
-                command,
-                args,
-                env: config.env,
-                description: config.description || 'Custom MCP server',
-                enabled: true,
-                autoStart: config.autoStart ?? false,
-            };
-            this.registry.servers[config.name] = server;
-            this.saveRegistry();
-            return { success: true, server };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
+            i++;
+            continue;
         }
-    }
-    addMCP(config) {
-        if (this.registry.servers[config.name]) {
-            return { success: false, error: `MCP '${config.name}' already exists` };
+        if (flag === '--transport') {
+            transport = tokens[++i];
+            i++;
+            continue;
         }
-        const server = {
-            name: config.name,
-            command: config.command,
-            args: config.args,
-            env: config.env,
-            description: config.description || 'Custom MCP server',
-            enabled: true,
-            autoStart: false,
-        };
-        this.registry.servers[config.name] = server;
-        this.saveRegistry();
-        return { success: true, server };
-    }
-    uninstallMCP(name) {
-        if (!this.registry.servers[name]) {
-            return { success: false, error: `MCP '${name}' not found` };
+        if (flag === '--env') {
+            const kv = tokens[++i];
+            const eq = kv.indexOf('=');
+            if (eq > 0)
+                env[kv.slice(0, eq)] = kv.slice(eq + 1);
+            i++;
+            continue;
         }
-        if (this.registry.builtIn.includes(name)) {
-            return { success: false, error: `Cannot uninstall built-in MCP '${name}'` };
+        if (flag === '--header') {
+            const kv = tokens[++i];
+            const colon = kv.indexOf(':');
+            if (colon > 0)
+                headers[kv.slice(0, colon).trim()] = kv.slice(colon + 1).trim();
+            i++;
+            continue;
         }
-        if (this.processes.has(name)) {
-            this.stopMCP(name);
+        i++;
+    }
+    if (i >= tokens.length)
+        return { error: 'Missing MCP server name' };
+    const name = tokens[i++];
+    if (i >= tokens.length)
+        return { error: 'Missing command or URL' };
+    const rest = tokens.slice(i);
+    const sep = rest.indexOf('--');
+    let entry;
+    if (sep === -1) {
+        // URL form: name url
+        entry = { type: transport ?? 'http', url: rest[0], headers, env, enabled: true, autoStart: true };
+    }
+    else {
+        // Everything after `--` is the full command string; `--` itself is not a command.
+        const command = rest[sep + 1];
+        const args = rest.slice(sep + 2);
+        entry = { type: 'stdio', command, args, env, enabled: true, autoStart: true };
+    }
+    return { name, entry, scope, scopeExplicit };
+}
+function tokenizeAddCommand(str) {
+    const tokens = [];
+    let current = '';
+    let inQuote = false;
+    for (let i = 0; i < str.length; i++) {
+        const ch = str[i];
+        if (inQuote) {
+            if (ch === inQuote) {
+                tokens.push(current);
+                current = '';
+                inQuote = false;
+            }
+            else {
+                current += ch;
+            }
+            continue;
         }
-        delete this.registry.servers[name];
-        this.saveRegistry();
-        return { success: true };
-    }
-    async startMCP(name) {
-        const server = this.registry.servers[name];
-        if (!server) {
-            return { success: false, error: `MCP '${name}' not found` };
+        if (ch === '"' || ch === "'") {
+            inQuote = ch;
+            continue;
         }
-        if (!server.enabled) {
-            return { success: false, error: `MCP '${name}' is disabled` };
+        if (/\s/.test(ch)) {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+            continue;
         }
-        if (this.processes.has(name)) {
-            return { success: false, error: `MCP '${name}' is already running` };
+        current += ch;
+    }
+    if (current)
+        tokens.push(current);
+    return tokens;
+}
+// ─── LineBuffer (pure, tested) ──────────────────────────────────────────────
+export class LineBuffer {
+    tail = '';
+    lines = [];
+    push(chunk) {
+        const data = this.tail + chunk;
+        const parts = data.split('\n');
+        this.tail = parts.pop() ?? '';
+        this.lines.push(...parts);
+        const out = this.lines;
+        this.lines = [];
+        return out;
+    }
+    flush() {
+        const out = this.lines;
+        this.lines = [];
+        if (this.tail) {
+            out.push(this.tail);
+            this.tail = '';
         }
-        try {
-            const child = spawn(server.command, server.args, {
-                env: { ...process.env, ...server.env },
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            const mcpProcess = {
-                server,
-                process: child,
-                tools: [],
-                ready: false,
-            };
-            this.processes.set(name, mcpProcess);
-            child.stdout?.on('data', (data) => {
-                this.handleMCPMessage(name, data.toString());
-            });
-            child.stderr?.on('data', (data) => {
-                console.error(`MCP ${name} error:`, data.toString());
-            });
-            child.on('exit', (code) => {
-                console.log(`MCP ${name} exited with code ${code}`);
-                this.processes.delete(name);
+        return out;
+    }
+}
+// ─── JSON-RPC base client ───────────────────────────────────────────────────
+class BaseJsonRpcClient {
+    id = 0;
+    pending = new Map();
+    dead = false;
+    serverName;
+    constructor(serverName) {
+        this.serverName = serverName;
+    }
+    nextId() {
+        return ++this.id;
+    }
+    request(method, params, timeoutMs = 60000) {
+        if (this.dead)
+            return Promise.reject(new Error(`MCP server ${this.serverName} is disconnected`));
+        const id = this.nextId();
+        const msg = { jsonrpc: '2.0', id, method, params };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP request ${method} timed out`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.sendMessage(msg).catch((e) => {
+                this.pending.delete(id);
+                clearTimeout(timer);
+                reject(e);
             });
-            await this.initializeMCP(name);
-            return { success: true, tools: mcpProcess.tools };
+        });
+    }
+    notify(method, params) {
+        if (this.dead)
+            return Promise.resolve();
+        return this.sendMessage({ jsonrpc: '2.0', method, params });
+    }
+    handleResponse(message) {
+        const id = message.id;
+        if (id == null)
+            return;
+        const entry = this.pending.get(id);
+        if (!entry)
+            return;
+        this.pending.delete(id);
+        clearTimeout(entry.timer);
+        if (message.error) {
+            entry.reject(new Error(String(message.error?.message ?? message.error)));
         }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
+        else {
+            entry.resolve(message.result);
         }
     }
-    stopMCP(name) {
-        const mcpProcess = this.processes.get(name);
-        if (!mcpProcess) {
-            return { success: false, error: `MCP '${name}' is not running` };
+    rejectAllPending(reason) {
+        this.dead = true;
+        for (const [id, entry] of this.pending) {
+            clearTimeout(entry.timer);
+            entry.reject(new Error(reason));
+            this.pending.delete(id);
         }
-        mcpProcess.process.kill();
-        this.processes.delete(name);
-        return { success: true };
     }
-    async initializeMCP(name) {
-        const mcpProcess = this.processes.get(name);
-        if (!mcpProcess)
-            return;
-        this.sendMCPMessage(name, {
-            jsonrpc: '2.0',
-            id: 1,
-            method: 'initialize',
-            params: {
-                protocolVersion: '2024-11-05',
-                capabilities: {
-                    roots: { listChanged: true },
-                },
-                clientInfo: {
-                    name: 'ikie-cli',
-                    version: '0.1.0',
-                },
-            },
+    async callTool(name, args, timeout) {
+        const result = await this.request('tools/call', { name, arguments: args }, timeout);
+        return flattenMcpContent(result);
+    }
+}
+function flattenMcpContent(result) {
+    if (!result || typeof result !== 'object')
+        return String(result);
+    const content = result.content;
+    if (!Array.isArray(content))
+        return JSON.stringify(result, null, 2);
+    const parts = [];
+    for (const block of content) {
+        if (block.type === 'text' && typeof block.text === 'string')
+            parts.push(block.text);
+        else
+            parts.push(JSON.stringify(block));
+    }
+    return parts.join('\n');
+}
+// ─── StdioClient ──────────────────────────────────────────────────────────────
+class StdioClient extends BaseJsonRpcClient {
+    process;
+    command;
+    args;
+    env;
+    stderrRing = [];
+    constructor(serverName, command, args, env) {
+        super(serverName);
+        this.command = command;
+        this.args = args;
+        this.env = env;
+    }
+    async connect() {
+        const child = spawn(this.command, this.args, {
+            env: { ...process.env, ...this.env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.process = child;
+        const lineBuffer = new LineBuffer();
+        // Wait for the process to actually start before sending JSON-RPC.
+        await new Promise((resolveSpawn, rejectSpawn) => {
+            child.once('spawn', resolveSpawn);
+            child.once('error', rejectSpawn);
+        });
+        child.stdout?.on('data', (data) => {
+            const lines = lineBuffer.push(data.toString());
+            for (const line of lines) {
+                try {
+                    const msg = JSON.parse(line);
+                    this.handleResponse(msg);
+                }
+                catch {
+                    // Ignore non-JSON lines
+                }
+            }
+        });
+        child.stderr?.on('data', (data) => {
+            const text = data.toString();
+            this.stderrRing.push(text);
+            if (this.stderrRing.length > 20)
+                this.stderrRing.shift();
+        });
+        child.on('exit', (code) => {
+            this.rejectAllPending(`MCP server ${this.serverName} exited (code ${code ?? 'unknown'})`);
+        });
+        child.on('error', (err) => {
+            this.rejectAllPending(`MCP server ${this.serverName} process error: ${err.message}`);
+        });
+        await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'ikie', version: VERSION },
+        });
+        await this.notify('notifications/initialized', {});
+        const toolsResult = await this.request('tools/list', {});
+        return toolsResult.tools ?? [];
+    }
+    async sendMessage(msg) {
+        if (!this.process || this.process.killed)
+            throw new Error('MCP stdio process not running');
+        return new Promise((resolve, reject) => {
+            this.process.stdin.write(JSON.stringify(msg) + '\n', (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
         });
-        await this.requestMCPTools(name);
     }
-    async requestMCPTools(name) {
-        this.sendMCPMessage(name, {
-            jsonrpc: '2.0',
-            id: 2,
-            method: 'tools/list',
+    close() {
+        this.dead = true;
+        if (this.process && !this.process.killed) {
+            this.process.kill();
+        }
+    }
+}
+// ─── HttpClient ───────────────────────────────────────────────────────────────
+class HttpClient extends BaseJsonRpcClient {
+    url;
+    headers;
+    env;
+    sessionId;
+    abortController;
+    constructor(serverName, url, headers, env) {
+        super(serverName);
+        this.url = url;
+        this.headers = headers;
+        this.env = env;
+    }
+    async connect() {
+        this.abortController = new AbortController();
+        await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'ikie', version: VERSION },
         });
+        await this.notify('notifications/initialized', {});
+        const toolsResult = await this.request('tools/list', {});
+        return toolsResult.tools ?? [];
     }
-    sendMCPMessage(name, message) {
-        const mcpProcess = this.processes.get(name);
-        if (!mcpProcess)
+    async sendMessage(msg) {
+        const id = msg.id;
+        const isNotification = id == null;
+        const headers = { 'Content-Type': 'application/json', ...this.headers };
+        if (this.sessionId)
+            headers['Mcp-Session-Id'] = this.sessionId;
+        const res = await fetch(this.url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(msg),
+            signal: this.abortController?.signal,
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status} ${res.statusText}`);
+        const sessionId = res.headers.get('Mcp-Session-Id');
+        if (sessionId)
+            this.sessionId = sessionId;
+        const contentType = res.headers.get('content-type') ?? '';
+        if (contentType.includes('text/event-stream')) {
+            await this.readSseResponse(res, id);
             return;
-        const json = JSON.stringify(message) + '\n';
-        mcpProcess.process.stdin?.write(json);
-    }
-    handleMCPMessage(name, data) {
-        const lines = data.split('\n').filter(Boolean);
-        for (const line of lines) {
-            try {
-                const message = JSON.parse(line);
-                if (message.result?.tools) {
-                    const mcpProcess = this.processes.get(name);
-                    if (mcpProcess) {
-                        mcpProcess.tools = message.result.tools;
-                        mcpProcess.ready = true;
-                    }
+        }
+        // Some servers return 202 Accepted with no body for notifications.
+        if (isNotification && res.status === 202)
+            return;
+        const body = await res.json();
+        if (!isNotification)
+            this.handleResponse(body);
+    }
+    async readSseResponse(res, expectedId) {
+        const reader = res.body?.getReader();
+        if (!reader)
+            return;
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() ?? '';
+                let dataLine;
+                for (const line of lines) {
+                    if (line.startsWith('data:'))
+                        dataLine = line.slice(5).trim();
                 }
-                if (message.id && this.messageHandlers.has(`${name}-${message.id}`)) {
-                    const handler = this.messageHandlers.get(`${name}-${message.id}`);
-                    handler?.(message);
-                    this.messageHandlers.delete(`${name}-${message.id}`);
+                if (dataLine) {
+                    try {
+                        const msg = JSON.parse(dataLine);
+                        if (expectedId != null && msg.id === expectedId) {
+                            this.handleResponse(msg);
+                            return;
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
                 }
             }
-            catch (error) {
-                console.error(`Failed to parse MCP message from ${name}:`, error);
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    close() {
+        this.dead = true;
+        this.abortController?.abort();
+    }
+}
+// ─── SseClient (deprecated, best-effort) ──────────────────────────────────────
+class SseClient extends BaseJsonRpcClient {
+    url;
+    headers;
+    env;
+    postUrl;
+    abortController;
+    constructor(serverName, url, headers, env) {
+        super(serverName);
+        this.url = url;
+        this.headers = headers;
+        this.env = env;
+    }
+    async connect() {
+        this.abortController = new AbortController();
+        // Open SSE stream to learn POST endpoint.
+        const res = await fetch(this.url, {
+            method: 'GET',
+            headers: this.headers,
+            signal: this.abortController.signal,
+        });
+        if (!res.ok)
+            throw new Error(`SSE connect failed: HTTP ${res.status}`);
+        if (!res.body)
+            throw new Error('SSE response has no body');
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let gotEndpoint = false;
+        while (!gotEndpoint) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            let i = 0;
+            while (i < lines.length) {
+                if (lines[i].startsWith('event: endpoint')) {
+                    // The data line follows immediately after the event line.
+                    if (i + 1 < lines.length && lines[i + 1].startsWith('data:')) {
+                        this.postUrl = resolve(this.url, lines[i + 1].slice(5).trim());
+                        gotEndpoint = true;
+                        break;
+                    }
+                }
+                i++;
             }
         }
+        reader.releaseLock();
+        if (!this.postUrl)
+            this.postUrl = this.url;
+        await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'ikie', version: VERSION },
+        });
+        await this.notify('notifications/initialized', {});
+        const toolsResult = await this.request('tools/list', {});
+        return toolsResult.tools ?? [];
+    }
+    async sendMessage(msg) {
+        if (!this.postUrl)
+            throw new Error('SSE endpoint not ready');
+        const id = msg.id;
+        const isNotification = id == null;
+        const res = await fetch(this.postUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...this.headers },
+            body: JSON.stringify(msg),
+            signal: this.abortController?.signal,
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        // Notifications may return 202 with no body.
+        if (isNotification && res.status === 202)
+            return;
+        const body = await res.json();
+        if (!isNotification)
+            this.handleResponse(body);
     }
-    async callMCPTool(serverName, toolName, args) {
-        const mcpProcess = this.processes.get(serverName);
-        if (!mcpProcess) {
-            return { success: false, error: `MCP '${serverName}' is not running` };
+    close() {
+        this.dead = true;
+        this.abortController?.abort();
+    }
+}
+// ─── Manager ──────────────────────────────────────────────────────────────────
+export class McpManager {
+    clients = new Map();
+    tools = new Map();
+    statuses = new Map();
+    cwd;
+    loadScope(path) {
+        if (!existsSync(path))
+            return {};
+        try {
+            return JSON.parse(readFileSync(path, 'utf-8'));
         }
-        if (!mcpProcess.ready) {
-            return { success: false, error: `MCP '${serverName}' is not ready` };
+        catch {
+            return {};
         }
-        return new Promise((resolve) => {
-            const id = Date.now();
-            const handlerKey = `${serverName}-${id}`;
-            const timeout = setTimeout(() => {
-                this.messageHandlers.delete(handlerKey);
-                resolve({ success: false, error: 'MCP tool call timeout' });
-            }, 30000);
-            this.messageHandlers.set(handlerKey, (message) => {
-                clearTimeout(timeout);
-                if (message.error) {
-                    resolve({ success: false, error: message.error.message });
-                }
-                else {
-                    resolve({ success: true, result: message.result });
-                }
-            });
-            this.sendMCPMessage(serverName, {
-                jsonrpc: '2.0',
-                id,
-                method: 'tools/call',
-                params: {
-                    name: toolName,
-                    arguments: args,
-                },
-            });
-        });
     }
-    getAllTools() {
-        const tools = [];
-        for (const [name, mcpProcess] of this.processes) {
-            if (mcpProcess.ready) {
-                for (const tool of mcpProcess.tools) {
-                    tools.push({ server: name, tool });
-                }
+    loadUserConfig() {
+        ensureUserDir();
+        this.migrateOldRegistry();
+        return this.loadScope(USER_MCP_FILE);
+    }
+    migrateOldRegistry() {
+        if (existsSync(USER_MCP_FILE) || !existsSync(OLD_REGISTRY_FILE))
+            return;
+        try {
+            const old = JSON.parse(readFileSync(OLD_REGISTRY_FILE, 'utf-8'));
+            if (!old.servers)
+                return;
+            const migrated = {};
+            for (const [name, s] of Object.entries(old.servers)) {
+                // Skip fake built-ins that point at non-existent files.
+                if (['database', 'puppeteer'].includes(name))
+                    continue;
+                migrated[name] = {
+                    type: 'stdio',
+                    command: s.command,
+                    args: s.args,
+                    env: s.env,
+                    description: s.description,
+                    enabled: s.enabled ?? true,
+                    autoStart: s.autoStart ?? false,
+                };
             }
+            writeFileSync(USER_MCP_FILE, JSON.stringify({ mcpServers: migrated }, null, 2));
         }
-        return tools;
-    }
-    listMCPs() {
-        return Object.entries(this.registry.servers).map(([name, server]) => ({
-            name,
-            description: server.description,
-            enabled: server.enabled,
-            running: this.processes.has(name),
-            builtIn: this.registry.builtIn.includes(name),
-            tools: this.processes.get(name)?.tools,
+        catch {
+            // ignore
+        }
+    }
+    resolveEnv(entry) {
+        return { ...process.env, ...entry.env };
+    }
+    createClient(name, entry) {
+        const env = this.resolveEnv(entry);
+        const transport = inferTransport(entry);
+        if (transport === 'stdio') {
+            if (!entry.command)
+                throw new Error(`stdio MCP server ${name} missing command`);
+            return new StdioClient(name, entry.command, entry.args ?? [], env);
+        }
+        if (transport === 'sse') {
+            if (!entry.url)
+                throw new Error(`sse MCP server ${name} missing url`);
+            return new SseClient(name, entry.url, entry.headers ?? {}, env);
+        }
+        if (!entry.url)
+            throw new Error(`http MCP server ${name} missing url`);
+        return new HttpClient(name, entry.url, entry.headers ?? {}, env);
+    }
+    async connectAll(cwd) {
+        this.cwd = cwd;
+        const local = this.loadScope(localMcpFile(cwd));
+        const project = this.loadScope(projectMcpFile(cwd));
+        const user = this.loadUserConfig();
+        const merged = mergeScopes(local, project, user);
+        await Promise.all(Object.entries(merged).map(async ([name, entry]) => {
+            if (entry.enabled === false || entry.autoStart === false) {
+                this.statuses.set(name, { name, enabled: entry.enabled !== false, connected: false, tools: [] });
+                return;
+            }
+            await this.connectServer(name, entry);
         }));
     }
-    setMCPEnabled(name, enabled) {
-        const server = this.registry.servers[name];
-        if (!server) {
-            return { success: false, error: `MCP '${name}' not found` };
+    async connectServer(name, entry) {
+        try {
+            const expanded = expandEnvVarsInEntry(entry, this.resolveEnv(entry));
+            const client = this.createClient(name, expanded);
+            const tools = await this.withTimeout(client.connect(), entry.timeout ?? 60000, `MCP server ${name} connect timed out`);
+            this.clients.set(name, client);
+            this.tools.set(name, tools);
+            this.statuses.set(name, { name, enabled: true, connected: true, tools });
         }
-        server.enabled = enabled;
-        this.saveRegistry();
-        return { success: true };
-    }
-    async startAutoStartMCPs() {
-        for (const [name, server] of Object.entries(this.registry.servers)) {
-            if (server.enabled && server.autoStart) {
-                await this.startMCP(name);
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.statuses.set(name, { name, enabled: true, connected: false, tools: [], error: message });
+        }
+    }
+    async withTimeout(p, ms, reason) {
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(reason)), ms);
+        });
+        return Promise.race([p.then(v => { clearTimeout(timer); return v; }), timeout]);
+    }
+    getToolDefsSync() {
+        const defs = [];
+        for (const [server, tools] of this.tools) {
+            for (const t of tools) {
+                defs.push({
+                    type: 'function',
+                    function: {
+                        name: mcpToolName(server, t.name),
+                        description: t.description ?? `MCP tool ${t.name} from ${server}`,
+                        parameters: (t.inputSchema ?? { type: 'object', properties: {} }),
+                    },
+                });
             }
         }
+        return defs;
     }
-    stopAllMCPs() {
-        for (const name of this.processes.keys()) {
-            this.stopMCP(name);
+    async callTool(qualified, args) {
+        const map = buildReverseToolMap(this.tools);
+        const q = map.get(qualified);
+        if (!q)
+            return `Error: unknown MCP tool ${qualified}`;
+        const client = this.clients.get(q.server);
+        if (!client)
+            return `Error: MCP server ${q.server} is not connected`;
+        const entry = this.findServerEntry(q.server);
+        const timeout = entry?.timeout ?? 60000;
+        try {
+            return await client.callTool(q.tool, args, timeout);
+        }
+        catch (err) {
+            return `Error calling MCP tool ${qualified}: ${err instanceof Error ? err.message : String(err)}`;
         }
     }
-}
-let mcpManager = null;
-export function getMCPManager() {
-    if (!mcpManager) {
-        mcpManager = new MCPManager();
+    findServerEntry(name) {
+        const cwd = this.cwd ?? process.cwd();
+        const merged = mergeScopes(this.loadScope(localMcpFile(cwd)), this.loadScope(projectMcpFile(cwd)), this.loadUserConfig());
+        return merged[name];
+    }
+    listServers() {
+        return [...this.statuses.values()].sort((a, b) => a.name.localeCompare(b.name));
     }
-    return mcpManager;
+    async addServer(name, entry, scope) {
+        const cwd = this.cwd ?? process.cwd();
+        const path = scope === 'user' ? USER_MCP_FILE : scope === 'project' ? projectMcpFile(cwd) : localMcpFile(cwd);
+        const cfg = this.loadScope(path);
+        cfg.mcpServers = cfg.mcpServers ?? {};
+        cfg.mcpServers[name] = entry;
+        ensureParentDir(path);
+        writeFileSync(path, JSON.stringify(cfg, null, 2));
+        await this.connectServer(name, entry);
+    }
+    removeServer(name, scope) {
+        const cwd = this.cwd ?? process.cwd();
+        const path = scope === 'user' ? USER_MCP_FILE : scope === 'project' ? projectMcpFile(cwd) : localMcpFile(cwd);
+        const cfg = this.loadScope(path);
+        if (!cfg.mcpServers?.[name])
+            return false;
+        delete cfg.mcpServers[name];
+        ensureParentDir(path);
+        writeFileSync(path, JSON.stringify(cfg, null, 2));
+        const client = this.clients.get(name);
+        if (client) {
+            client.close();
+            this.clients.delete(name);
+        }
+        this.tools.delete(name);
+        this.statuses.delete(name);
+        return true;
+    }
+    async reconnectServer(name) {
+        const cwd = this.cwd ?? process.cwd();
+        const merged = mergeScopes(this.loadScope(localMcpFile(cwd)), this.loadScope(projectMcpFile(cwd)), this.loadUserConfig());
+        const entry = merged[name];
+        if (!entry)
+            throw new Error(`MCP server ${name} not found in config`);
+        const client = this.clients.get(name);
+        if (client)
+            client.close();
+        this.clients.delete(name);
+        this.tools.delete(name);
+        await this.connectServer(name, entry);
+    }
+    disconnectAll() {
+        for (const client of this.clients.values())
+            client.close();
+        this.clients.clear();
+        this.tools.clear();
+    }
+}
+function ensureParentDir(path) {
+    const parent = path.includes('/') ? path.slice(0, path.lastIndexOf('/')) : path.slice(0, path.lastIndexOf('\\'));
+    if (parent && !existsSync(parent))
+        mkdirSync(parent, { recursive: true });
+}
+let manager = null;
+export function getMcpManager() {
+    if (!manager)
+        manager = new McpManager();
+    return manager;
 }
+// Out of scope: WebSocket transport, OAuth/dynamic client registration,
+// MCP resources/prompts, plugin-bundled servers.