kiku-agent 1.0.5 → 1.0.7

package/server/agent/mcpClient.js

@@ -1,364 +1,436 @@
-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.5' };
-    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;
-  }
-}
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { PACKAGE_VERSION } from './version.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: PACKAGE_VERSION };
+    this.autoLoad = options.autoLoad !== false;
+    this.servers = new Map();
+    this.persistedConfigs = 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 cleanConfig = { ...serverConfig, enabled: true };
+      delete cleanConfig.lastError;
+
+      const serverEntry = {
+        name,
+        config: cleanConfig,
+        client,
+        transport,
+        tools,
+        resources,
+        prompts,
+        connectedAt: new Date().toISOString(),
+      };
+
+      this.servers.set(name, serverEntry);
+      this.persistedConfigs.set(name, cleanConfig);
+      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(() => {});
+      this.persistedConfigs.set(name, { ...serverConfig, lastError: err.message });
+      throw new Error(`Failed connecting to MCP server "${name}": ${err.message}`);
+    }
+  }
+
+  async disconnect(serverName, { persist = false } = {}) {
+    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 remove(serverName, { persist = true } = {}) {
+    await this.disconnect(serverName, { persist: false });
+    const hadPersisted = this.persistedConfigs.delete(serverName);
+    if (persist) {
+      await this.savePersistedConfig().catch(() => {});
+    }
+    return hadPersisted;
+  }
+
+  async disconnectAll() {
+    const names = [...this.servers.keys()];
+    for (const name of names) {
+      await this.disconnect(name, { persist: false });
+    }
+  }
+
+  async reconnect(serverName) {
+    const cfg = this.persistedConfigs.get(serverName);
+    if (!cfg) {
+      throw new Error(`MCP server "${serverName}" is not configured.`);
+    }
+    return this.connect(serverName, cfg, { persist: true });
+  }
+
+  async reconnectAll() {
+    const results = [];
+    for (const [name, cfg] of this.persistedConfigs.entries()) {
+      if (cfg.enabled === false || cfg.disabled === true) 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 });
+      }
+    }
+    return results;
+  }
+
+  _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 = [];
+    const seen = new Set();
+
+    for (const [name, server] of this.servers.entries()) {
+      seen.add(name);
+      list.push({
+        name,
+        status: 'connected',
+        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,
+        config: server.config,
+      });
+    }
+
+    for (const [name, cfg] of this.persistedConfigs.entries()) {
+      if (seen.has(name)) continue;
+      list.push({
+        name,
+        status: cfg.lastError ? 'error' : (cfg.enabled === false ? 'disabled' : 'saved_offline'),
+        type: cfg.type || (cfg.command ? 'stdio' : 'streamable-http'),
+        toolsCount: 0,
+        resourcesCount: 0,
+        promptsCount: 0,
+        error: cfg.lastError || null,
+        config: cfg,
+      });
+    }
+
+    return {
+      activeServersCount: this.servers.size,
+      totalConfiguredCount: this.persistedConfigs.size,
+      totalToolsCount: this.getToolsSchema().length,
+      servers: list,
+    };
+  }
+
+  async savePersistedConfig(customPath) {
+    try {
+      const filePath = customPath || path.join(KIKU_DATA_DIR, 'mcp_servers.json');
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+
+      const serversObj = {};
+      for (const [name, cfg] of this.persistedConfigs.entries()) {
+        const clean = { ...cfg };
+        delete clean.lastError;
+        serversObj[name] = clean;
+      }
+      for (const [name, entry] of this.servers.entries()) {
+        if (!serversObj[name]) {
+          serversObj[name] = entry.config;
+        }
+      }
+
+      await fs.writeFile(filePath, JSON.stringify({ mcpServers: serversObj }, null, 2), 'utf8');
+      return { success: true, filePath, count: Object.keys(serversObj).length };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async saveToWorkspace(filename = '.mcp.json') {
+    const workspacePath = path.resolve(process.cwd(), filename);
+    return this.savePersistedConfig(workspacePath);
+  }
+
+  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)) {
+          this.persistedConfigs.set(name, cfg);
+          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)) {
+      this.persistedConfigs.set(name, cfg);
+      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;
+  }
+}