kiku-agent 1.0.0 → 1.0.4

package/server/agent/mcpClient.js

@@ -0,0 +1,364 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { KIKU_DATA_DIR } from './appPaths.js';
+
+export class McpClientManager {
+  constructor(options = {}) {
+    this.clientInfo = options.clientInfo || { name: 'kiku-agent', version: '1.0.4' };
+    this.autoLoad = options.autoLoad !== false;
+    this.servers = new Map();
+    this.toolRegistry = new Map();
+  }
+
+  async connect(serverName, serverConfig = {}, { persist = true } = {}) {
+    const name = String(serverName || '').trim();
+    if (!name) throw new Error('Server name is required to connect to MCP.');
+
+    if (this.servers.has(name)) {
+      await this.disconnect(name, { persist: false });
+    }
+
+    let transport;
+    let cmd = serverConfig.command;
+    let args = serverConfig.args || [];
+    if (Array.isArray(cmd)) {
+      args = [...cmd.slice(1), ...args];
+      cmd = cmd[0];
+    }
+    const isStdio = Boolean(cmd || serverConfig.type === 'stdio' || serverConfig.type === 'local');
+    const isSse = serverConfig.type === 'sse';
+
+    if (isStdio) {
+      transport = new StdioClientTransport({
+        command: cmd,
+        args: args,
+        env: { ...process.env, ...(serverConfig.env || serverConfig.environment || {}) },
+        cwd: serverConfig.cwd || process.cwd(),
+        stderr: 'pipe',
+      });
+    } else if (isSse) {
+      const url = new URL(serverConfig.url);
+      transport = new SSEClientTransport(url, {
+        eventSourceInit: serverConfig.headers ? { headers: serverConfig.headers } : undefined,
+        requestInit: serverConfig.headers ? { headers: serverConfig.headers } : undefined,
+      });
+    } else {
+      const targetUrl = serverConfig.url || serverConfig.serverUrl || serverConfig.httpUrl;
+      const url = new URL(targetUrl);
+      const transportOpts = {};
+      if (serverConfig.headers) transportOpts.headers = serverConfig.headers;
+      transport = new StreamableHTTPClientTransport(url, transportOpts);
+    }
+
+    const client = new Client(this.clientInfo, {
+      capabilities: {
+        tools: {},
+        resources: {},
+        prompts: {},
+      },
+    });
+
+    try {
+      await client.connect(transport);
+
+      let tools = [];
+      let resources = [];
+      let prompts = [];
+
+      try {
+        const toolsResult = await client.listTools();
+        tools = toolsResult.tools || [];
+      } catch (err) {
+        console.warn(`[MCP] Failed to list tools from ${name}: ${err.message}`);
+      }
+
+      try {
+        const resResult = await client.listResources();
+        resources = resResult.resources || [];
+      } catch {}
+
+      try {
+        const promptResult = await client.listPrompts();
+        prompts = promptResult.prompts || [];
+      } catch {}
+
+      const serverEntry = {
+        name,
+        config: serverConfig,
+        client,
+        transport,
+        tools,
+        resources,
+        prompts,
+        connectedAt: new Date().toISOString(),
+      };
+
+      this.servers.set(name, serverEntry);
+      this._rebuildToolRegistry();
+
+      if (persist) {
+        await this.savePersistedConfig().catch(() => {});
+      }
+
+      return {
+        success: true,
+        serverName: name,
+        toolsCount: tools.length,
+        resourcesCount: resources.length,
+        promptsCount: prompts.length,
+        tools,
+      };
+    } catch (err) {
+      await transport.close().catch(() => {});
+      throw new Error(`Failed connecting to MCP server "${name}": ${err.message}`);
+    }
+  }
+
+  async disconnect(serverName, { persist = true } = {}) {
+    const entry = this.servers.get(serverName);
+    if (!entry) return false;
+
+    try {
+      await entry.client.close().catch(() => {});
+      await entry.transport.close().catch(() => {});
+      if (entry.transport?._process) {
+        try {
+          entry.transport._process.kill('SIGKILL');
+          entry.transport._process.stdout?.destroy?.();
+          entry.transport._process.stderr?.destroy?.();
+          entry.transport._process.stdin?.destroy?.();
+          entry.transport._process.unref?.();
+        } catch {}
+      }
+    } catch {}
+
+    this.servers.delete(serverName);
+    this._rebuildToolRegistry();
+
+    if (persist) {
+      await this.savePersistedConfig().catch(() => {});
+    }
+    return true;
+  }
+
+  async disconnectAll() {
+    const names = [...this.servers.keys()];
+    for (const name of names) {
+      await this.disconnect(name, { persist: false });
+    }
+  }
+
+  _rebuildToolRegistry() {
+    this.toolRegistry.clear();
+
+    for (const [serverName, serverEntry] of this.servers.entries()) {
+      for (const tool of serverEntry.tools) {
+        const directName = `mcp_${serverName}_${tool.name}`;
+        this.toolRegistry.set(directName, {
+          serverName,
+          originalName: tool.name,
+          schema: tool,
+        });
+
+        if (!this.toolRegistry.has(tool.name)) {
+          this.toolRegistry.set(tool.name, {
+            serverName,
+            originalName: tool.name,
+            schema: tool,
+          });
+        }
+      }
+    }
+  }
+
+  isMcpTool(toolName) {
+    return this.toolRegistry.has(toolName);
+  }
+
+  getToolsSchema() {
+    const schemas = [];
+    const seenNames = new Set();
+
+    for (const [serverName, serverEntry] of this.servers.entries()) {
+      for (const tool of serverEntry.tools) {
+        const toolName = `mcp_${serverName}_${tool.name}`;
+        if (seenNames.has(toolName)) continue;
+        seenNames.add(toolName);
+
+        schemas.push({
+          type: 'function',
+          function: {
+            name: toolName,
+            description: `[MCP Server: ${serverName}] ${tool.description || `Tool from ${serverName}`}`,
+            parameters: tool.inputSchema || { type: 'object', properties: {} },
+          },
+          _mcp: {
+            serverName,
+            originalName: tool.name,
+          },
+        });
+      }
+    }
+
+    return schemas;
+  }
+
+  async callTool(toolName, args = {}) {
+    const registration = this.toolRegistry.get(toolName);
+    if (!registration) {
+      return {
+        status: 'error',
+        message: `MCP tool "${toolName}" is not registered on any active MCP server.`,
+      };
+    }
+
+    const serverEntry = this.servers.get(registration.serverName);
+    if (!serverEntry) {
+      return {
+        status: 'error',
+        message: `MCP server "${registration.serverName}" is disconnected.`,
+      };
+    }
+
+    try {
+      const response = await serverEntry.client.callTool({
+        name: registration.originalName,
+        arguments: args,
+      });
+
+      if (response.isError) {
+        const errText = response.content?.map(c => c.text).filter(Boolean).join('\n') || 'Unknown MCP tool error';
+        return {
+          status: 'error',
+          server: registration.serverName,
+          tool: registration.originalName,
+          message: errText,
+        };
+      }
+
+      let parsedPayload = null;
+      let textContent = '';
+      if (response.content && Array.isArray(response.content)) {
+        for (const item of response.content) {
+          if (item.type === 'text' && item.text) {
+            textContent += item.text + '\n';
+            try {
+              if (!parsedPayload && item.text.trim().startsWith('{') && item.text.trim().endsWith('}')) {
+                parsedPayload = JSON.parse(item.text);
+              }
+            } catch {}
+          }
+        }
+      }
+
+      return {
+        status: 'success',
+        server: registration.serverName,
+        tool: registration.originalName,
+        ...(parsedPayload && typeof parsedPayload === 'object' ? parsedPayload : {}),
+        content: textContent.trim(),
+        _rawMcp: response.content,
+      };
+    } catch (err) {
+      return {
+        status: 'error',
+        server: registration.serverName,
+        tool: registration.originalName,
+        message: `Failed executing MCP tool "${registration.originalName}": ${err.message}`,
+      };
+    }
+  }
+
+  getStatus() {
+    const list = [];
+    for (const [name, server] of this.servers.entries()) {
+      list.push({
+        name,
+        type: server.config.type || (server.config.command ? 'stdio' : 'streamable-http'),
+        toolsCount: server.tools.length,
+        resourcesCount: server.resources.length,
+        promptsCount: server.prompts.length,
+        connectedAt: server.connectedAt,
+      });
+    }
+    return {
+      activeServersCount: this.servers.size,
+      totalToolsCount: this.getToolsSchema().length,
+      servers: list,
+    };
+  }
+
+  async savePersistedConfig() {
+    try {
+      const dir = KIKU_DATA_DIR;
+      await fs.mkdir(dir, { recursive: true });
+      const filePath = path.join(dir, 'mcp_servers.json');
+
+      const serversObj = {};
+      for (const [name, entry] of this.servers.entries()) {
+        serversObj[name] = entry.config;
+      }
+
+      await fs.writeFile(filePath, JSON.stringify({ mcpServers: serversObj }, null, 2), 'utf8');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async loadPersistedServers() {
+    if (this.autoLoad === false) return [];
+    const results = [];
+    const candidates = [
+      path.join(KIKU_DATA_DIR, 'mcp_servers.json'),
+      path.join(process.cwd(), 'opencode.json'),
+      path.join(process.cwd(), '.mcp.json'),
+      path.join(process.cwd(), 'mcp.json'),
+    ];
+
+    for (const filePath of candidates) {
+      try {
+        const content = await fs.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(content);
+        const serversObj = parsed.mcpServers || parsed.mcp || {};
+        for (const [name, cfg] of Object.entries(serversObj)) {
+          if (cfg.enabled === false || cfg.disabled === true) continue;
+          if (this.servers.has(name)) continue;
+          try {
+            const res = await this.connect(name, cfg, { persist: false });
+            results.push(res);
+          } catch (err) {
+            results.push({ success: false, serverName: name, error: err.message });
+          }
+        }
+      } catch {}
+    }
+
+    return results;
+  }
+
+  async loadConfigFile(configPath) {
+    const resolvedPath = path.resolve(process.cwd(), configPath);
+    const content = await fs.readFile(resolvedPath, 'utf8');
+    const parsed = JSON.parse(content);
+
+    const serversObj = parsed.mcpServers || parsed.mcp || {};
+    const results = [];
+
+    for (const [name, cfg] of Object.entries(serversObj)) {
+      if (cfg.enabled === false || cfg.disabled === true) continue;
+      try {
+        const res = await this.connect(name, cfg);
+        results.push(res);
+      } catch (err) {
+        results.push({ success: false, serverName: name, error: err.message });
+      }
+    }
+
+    return results;
+  }
+}