coding-tool-x 3.6.6 → 3.6.8

package/src/server/services/mcp-client.js

@@ -1,8 +1,8 @@
 /**
  * MCP JSON-RPC Client Wrapper
  *
- * Reusable client for communicating with MCP servers over stdio or HTTP/SSE
- * transports using the JSON-RPC 2.0 protocol.
+ * Reusable client for communicating with MCP servers over stdio, Streamable
+ * HTTP, or legacy SSE transports using the JSON-RPC 2.0 protocol.
  *
  * Usage:
  *   const client = new McpClient({ type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-time'] });
@@ -166,6 +166,49 @@ function buildMissingCommandMessage(command, resolvedCommand, env = {}) {
   return [hint.title, ...hint.details].join('\n')
 }
 
+function parseSseEvent(block = '') {
+  const lines = String(block).split('\n');
+  const dataLines = [];
+  let eventType = 'message';
+
+  for (const rawLine of lines) {
+    const line = rawLine.trimEnd();
+    if (!line || line.startsWith(':')) {
+      continue;
+    }
+
+    const separatorIdx = line.indexOf(':');
+    const field = separatorIdx === -1 ? line : line.slice(0, separatorIdx);
+    let value = separatorIdx === -1 ? '' : line.slice(separatorIdx + 1);
+    if (value.startsWith(' ')) {
+      value = value.slice(1);
+    }
+
+    if (field === 'event') {
+      eventType = value || 'message';
+    } else if (field === 'data') {
+      dataLines.push(value);
+    }
+  }
+
+  if (dataLines.length === 0) {
+    return null;
+  }
+
+  return {
+    eventType,
+    data: dataLines.join('\n')
+  };
+}
+
+function resolveLegacySseEndpoint(baseUrl, endpoint) {
+  const endpointText = String(endpoint || '').trim();
+  if (!endpointText) {
+    throw new McpClientError('SSE endpoint event did not include a request URL');
+  }
+  return new URL(endpointText, baseUrl).toString();
+}
+
 // ============================================================================
 // McpClient
 // ============================================================================
@@ -173,13 +216,13 @@ function buildMissingCommandMessage(command, resolvedCommand, env = {}) {
 class McpClient extends EventEmitter {
   /**
    * @param {object} serverSpec - Server specification
-   * @param {string} [serverSpec.type='stdio'] - Transport type: 'stdio' | 'http' | 'sse'
+   * @param {string} [serverSpec.type='stdio'] - Transport type: 'stdio' | 'streamable_http' | 'sse'
    * @param {string} [serverSpec.command] - Command for stdio transport
    * @param {string[]} [serverSpec.args] - Args for stdio transport
    * @param {object} [serverSpec.env] - Additional env vars for stdio transport
    * @param {string} [serverSpec.cwd] - Working directory for stdio transport
-   * @param {string} [serverSpec.url] - URL for http/sse transport
-   * @param {object} [serverSpec.headers] - Additional headers for http/sse transport
+   * @param {string} [serverSpec.url] - URL for streamable_http/sse transport
+   * @param {object} [serverSpec.headers] - Additional headers for streamable_http/sse transport
    * @param {object} [options] - Client options
    * @param {number} [options.timeout=10000] - Operation timeout in ms
    */
@@ -205,6 +248,10 @@ class McpClient extends EventEmitter {
     this._sseAbortController = null;
     this._httpSessionUrl = null;
     this._httpSessionId = null;
+    this._legacySseMode = false;
+    this._sseRequest = null;
+    this._sseResponse = null;
+    this._sseBuffer = '';
     this._negotiatedProtocolVersion = MCP_PROTOCOL_VERSION;
   }
 
@@ -223,7 +270,7 @@ class McpClient extends EventEmitter {
 
     if (this._type === 'stdio') {
       await this._connectStdio();
-    } else if (this._type === 'http' || this._type === 'sse') {
+    } else if (this._type === 'streamable_http' || this._type === 'sse') {
       await this._connectHttp();
     } else {
       throw new McpClientError(`Unsupported transport type: ${this._type}`);
@@ -572,17 +619,61 @@ class McpClient extends EventEmitter {
     const { url } = this._spec;
 
     if (!url) {
-      throw new McpClientError('http/sse transport requires a "url" field');
+      throw new McpClientError('streamable_http/sse transport requires a "url" field');
     }
 
-    // For HTTP transport, we verify the server is reachable with a GET request.
-    // The MCP Streamable HTTP transport uses a single endpoint for both
-    // POST (JSON-RPC requests) and GET (SSE event stream).
+    try {
+      new URL(url);
+    } catch (err) {
+      throw new McpClientError(`Invalid URL: ${err.message}`);
+    }
+
+    if (this._type === 'sse') {
+      await this._connectLegacySse();
+      return;
+    }
+
+    // Streamable HTTP sends each JSON-RPC message as a POST to the MCP endpoint.
+    // Do not probe with GET here: valid servers may return 405 when they do not
+    // expose an unsolicited SSE stream on the same endpoint.
+    this._httpSessionUrl = url;
+  }
+
+  /** @private */
+  async _connectLegacySse() {
+    const { url } = this._spec;
+
     return new Promise((resolve, reject) => {
+      let settled = false;
       const timer = setTimeout(() => {
-        reject(new McpClientError(`HTTP connection timeout after ${this._timeout}ms`));
+        cleanup();
+        reject(new McpClientError(`SSE connection timeout after ${this._timeout}ms`));
       }, this._timeout);
 
+      const cleanup = () => {
+        clearTimeout(timer);
+        if (this._sseRequest && !this._sseRequest.destroyed) {
+          this._sseRequest.destroy();
+        }
+        if (this._sseResponse && !this._sseResponse.destroyed) {
+          this._sseResponse.destroy();
+        }
+        this._sseRequest = null;
+        this._sseResponse = null;
+      };
+
+      const settle = (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        if (err) {
+          cleanup();
+          reject(err);
+        } else {
+          resolve();
+        }
+      };
+
       try {
         const parsedUrl = new URL(url);
         const client = parsedUrl.protocol === 'https:' ? https : http;
@@ -600,36 +691,70 @@ class McpClient extends EventEmitter {
         };
 
         const req = client.request(options, (res) => {
-          clearTimeout(timer);
+          this._sseResponse = res;
 
           if (res.statusCode >= 200 && res.statusCode < 400) {
-            // Store the base URL for sending requests
-            this._httpSessionUrl = url;
-            // We don't keep this SSE connection open during connect;
-            // we will open a new one per request or use POST.
-            res.destroy();
-            resolve();
+            const contentType = res.headers['content-type'] || '';
+            if (!contentType.includes('text/event-stream')) {
+              settle(new McpClientError(`SSE endpoint returned unsupported content type: ${contentType || 'unknown'}`));
+              return;
+            }
+
+            res.on('data', (chunk) => {
+              this._sseBuffer += chunk.toString();
+              const events = this._drainSseEvents();
+
+              for (const event of events) {
+                if (!settled && event.eventType === 'endpoint') {
+                  try {
+                    this._httpSessionUrl = resolveLegacySseEndpoint(url, event.data);
+                    this._legacySseMode = true;
+                    settle(null);
+                  } catch (err) {
+                    settle(err);
+                  }
+                  continue;
+                }
+
+                this._handleSseEvent(event);
+              }
+            });
+
+            res.on('end', () => {
+              if (!settled) {
+                settle(new McpClientError('SSE endpoint closed before endpoint event'));
+                return;
+              }
+              this._handleHttpDisconnect('SSE stream closed');
+            });
+
+            res.on('error', (err) => {
+              if (!settled) {
+                settle(new McpClientError(`SSE stream error: ${err.message}`));
+                return;
+              }
+              this._handleHttpDisconnect(`SSE stream error: ${err.message}`);
+            });
           } else {
-            res.destroy();
-            reject(new McpClientError(`HTTP server returned status ${res.statusCode}`));
+            res.resume();
+            settle(new McpClientError(`SSE server returned status ${res.statusCode}`));
           }
         });
 
+        this._sseRequest = req;
+
         req.on('error', (err) => {
-          clearTimeout(timer);
-          reject(new McpClientError(`HTTP connection failed: ${err.message}`));
+          settle(new McpClientError(`SSE connection failed: ${err.message}`));
         });
 
         req.on('timeout', () => {
           req.destroy();
-          clearTimeout(timer);
-          reject(new McpClientError(`HTTP connection timeout after ${this._timeout}ms`));
+          settle(new McpClientError(`SSE connection timeout after ${this._timeout}ms`));
         });
 
         req.end();
       } catch (err) {
-        clearTimeout(timer);
-        reject(new McpClientError(`Invalid URL: ${err.message}`));
+        settle(new McpClientError(`Invalid URL: ${err.message}`));
       }
     });
   }
@@ -684,7 +809,7 @@ class McpClient extends EventEmitter {
             const trimmedData = data.trim();
 
             if (!trimmedData) {
-              if (isNotification || res.statusCode === 202 || res.statusCode === 204) {
+              if (isNotification || res.statusCode === 204 || (res.statusCode === 202 && this._legacySseMode)) {
                 resolve();
                 return;
               }
@@ -745,39 +870,101 @@ class McpClient extends EventEmitter {
 
   /** @private */
   _parseSsePayload(data) {
-    // Parse Server-Sent Events format
-    const lines = data.split('\n');
-    let eventData = '';
-
-    for (const line of lines) {
-      if (line.startsWith('data: ')) {
-        eventData += line.slice(6);
-      } else if (line === '' && eventData) {
-        try {
-          const msg = JSON.parse(eventData);
-          this._handleMessage(msg);
-        } catch (err) {
-          this.emit('stderr', `[invalid SSE data]: ${eventData}`);
-        }
-        eventData = '';
+    const previousBuffer = this._sseBuffer;
+    this._sseBuffer = data;
+    const events = this._drainSseEvents({ flush: true });
+    this._sseBuffer = previousBuffer;
+
+    for (const event of events) {
+      this._handleSseEvent(event);
+    }
+  }
+
+  /** @private */
+  _drainSseEvents({ flush = false } = {}) {
+    const events = [];
+    let normalized = this._sseBuffer.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    let delimiterIdx;
+
+    while ((delimiterIdx = normalized.indexOf('\n\n')) !== -1) {
+      const block = normalized.slice(0, delimiterIdx);
+      normalized = normalized.slice(delimiterIdx + 2);
+      const event = parseSseEvent(block);
+      if (event && event.data) {
+        events.push(event);
       }
     }
 
-    // Handle trailing data without a final empty line
-    if (eventData) {
-      try {
-        const msg = JSON.parse(eventData);
-        this._handleMessage(msg);
-      } catch (err) {
-        this.emit('stderr', `[invalid SSE data]: ${eventData}`);
+    if (flush && normalized.trim()) {
+      const event = parseSseEvent(normalized);
+      if (event && event.data) {
+        events.push(event);
       }
+      normalized = '';
+    }
+
+    this._sseBuffer = normalized;
+    return events;
+  }
+
+  /** @private */
+  _handleSseEvent(event) {
+    if (!event || !event.data || event.data === '[DONE]') {
+      return;
+    }
+
+    if (event.eventType === 'endpoint') {
+      return;
+    }
+
+    try {
+      const msg = JSON.parse(event.data);
+      this._handleMessage(msg);
+    } catch (err) {
+      this.emit('stderr', `[invalid SSE data]: ${event.data}`);
     }
   }
 
+  /** @private */
+  _handleHttpDisconnect(message) {
+    if (!this._connected) {
+      return;
+    }
+
+    this._connected = false;
+    this._initialized = false;
+
+    for (const [id, pending] of this._pending) {
+      clearTimeout(pending.timer);
+      pending.reject(new McpClientError(message));
+    }
+    this._pending.clear();
+
+    this.emit('disconnected');
+  }
+
   /** @private */
   _disconnectHttp() {
+    if (this._sseRequest && !this._sseRequest.destroyed) {
+      try {
+        this._sseRequest.destroy();
+      } catch (e) {
+        // ignore
+      }
+    }
+    if (this._sseResponse && !this._sseResponse.destroyed) {
+      try {
+        this._sseResponse.destroy();
+      } catch (e) {
+        // ignore
+      }
+    }
+    this._sseRequest = null;
+    this._sseResponse = null;
+    this._sseBuffer = '';
     this._httpSessionUrl = null;
     this._httpSessionId = null;
+    this._legacySseMode = false;
     this._negotiatedProtocolVersion = MCP_PROTOCOL_VERSION;
   }
 

package/src/server/services/mcp-service.js

@@ -9,8 +9,6 @@ const path = require('path');
 const os = require('os');
 const toml = require('@iarna/toml');
 const { spawn } = require('child_process');
-const http = require('http');
-const https = require('https');
 const { McpClient, buildMissingCommandMessage, createMissingCommandHint } = require('./mcp-client');
 const { NATIVE_PATHS, PATHS } = require('../../config/paths');
 const { resolvePreferredHomeDir } = require('../../utils/home-dir');
@@ -35,6 +33,18 @@ const OPENCODE_CONFIG_PATHS = {
 // serverId -> { client, timestamp }
 const mcpClientPool = new Map();
 const POOL_TTL = 5 * 60 * 1000; // 5 minutes
+const STREAMABLE_HTTP_TYPE = 'streamable_http';
+const MCP_SERVER_TYPES = ['stdio', STREAMABLE_HTTP_TYPE, 'sse'];
+const REMOTE_MCP_SERVER_TYPES = [STREAMABLE_HTTP_TYPE, 'sse'];
+
+function normalizeServerSpec(spec = {}) {
+  if (!spec || typeof spec !== 'object') {
+    return spec;
+  }
+  const normalized = { ...spec };
+  normalized.type = normalized.type || 'stdio';
+  return normalized;
+}
 
 // MCP 预设模板
 const MCP_PRESETS = [
@@ -545,6 +555,7 @@ function getAllServers() {
       continue;
     }
     server.apps = normalizeServerApps(server.apps);
+    server.server = normalizeServerSpec(server.server);
   }
 
   return servers;
@@ -568,6 +579,8 @@ async function saveServer(server, options = {}) {
     throw new Error('MCP 服务器 ID 不能为空');
   }
 
+  server.server = normalizeServerSpec(server.server);
+
   // 验证服务器配置
   validateServerSpec(server.server);
 
@@ -675,15 +688,15 @@ function validateServerSpec(spec) {
 
   const type = spec.type || 'stdio';
 
-  if (!['stdio', 'http', 'sse'].includes(type)) {
-    throw new Error(`无效的服务器类型: ${type}，必须是 stdio、http 或 sse`);
+  if (!MCP_SERVER_TYPES.includes(type)) {
+    throw new Error(`无效的服务器类型: ${spec.type || type}，必须是 stdio、streamable_http 或 sse`);
   }
 
   if (type === 'stdio') {
     if (!spec.command || !spec.command.trim()) {
       throw new Error('stdio 类型必须指定 command');
     }
-  } else if (type === 'http' || type === 'sse') {
+  } else if (REMOTE_MCP_SERVER_TYPES.includes(type)) {
     if (!spec.url || !spec.url.trim()) {
       throw new Error(`${type} 类型必须指定 url`);
     }
@@ -892,7 +905,7 @@ function convertToCodexFormat(spec) {
     if (spec.cwd) {
       result.cwd = spec.cwd;
     }
-  } else if (result.type === 'http' || result.type === 'sse') {
+  } else if (REMOTE_MCP_SERVER_TYPES.includes(result.type)) {
     result.url = spec.url || '';
     if (spec.headers && Object.keys(spec.headers).length > 0) {
       result.http_headers = spec.headers;
@@ -1023,7 +1036,7 @@ function convertFromOpenCodeFormat(spec) {
 
   if (sourceType === 'remote') {
     const result = {
-      type: 'http',
+      type: STREAMABLE_HTTP_TYPE,
       url: spec.url || ''
     };
     if (spec.headers && typeof spec.headers === 'object') {
@@ -1033,7 +1046,7 @@ function convertFromOpenCodeFormat(spec) {
   }
 
   // 已经是通用格式时直接兼容处理
-  if (sourceType === 'stdio' || sourceType === 'http' || sourceType === 'sse') {
+  if (sourceType === 'stdio' || REMOTE_MCP_SERVER_TYPES.includes(sourceType)) {
     return convertFromCodexFormat(spec);
   }
 
@@ -1256,7 +1269,7 @@ function convertFromCodexFormat(spec) {
     if (spec.cwd) {
       result.cwd = spec.cwd;
     }
-  } else if (result.type === 'http' || result.type === 'sse') {
+  } else if (REMOTE_MCP_SERVER_TYPES.includes(result.type)) {
     result.url = spec.url || '';
     if (spec.http_headers) {
       result.headers = spec.http_headers;
@@ -1324,7 +1337,7 @@ async function testServer(serverId) {
   try {
     if (type === 'stdio') {
       return await testStdioServer(spec);
-    } else if (type === 'http' || type === 'sse') {
+    } else if (REMOTE_MCP_SERVER_TYPES.includes(type)) {
       return await testHttpServer(spec);
     } else {
       return { success: false, message: `不支持的服务器类型: ${type}` };
@@ -1468,65 +1481,39 @@ async function testStdioServer(spec) {
 }
 
 /**
- * 测试 http/sse 类型服务器
+ * 测试 streamable_http/sse 类型服务器
  */
 async function testHttpServer(spec) {
-  return new Promise((resolve) => {
-    const startTime = Date.now();
-    const timeout = 10000;
-
-    try {
-      const url = new URL(spec.url);
-      const isHttps = url.protocol === 'https:';
-      const client = isHttps ? https : http;
-
-      const options = {
-        hostname: url.hostname,
-        port: url.port || (isHttps ? 443 : 80),
-        path: url.pathname + url.search,
-        method: 'GET',
-        timeout: timeout,
-        headers: {
-          ...spec.headers
-        }
-      };
-
-      const req = client.request(options, (res) => {
-        resolve({
-          success: res.statusCode >= 200 && res.statusCode < 500,
-          message: res.statusCode >= 200 && res.statusCode < 400
-            ? `服务器响应正常 (HTTP ${res.statusCode})`
-            : `服务器响应异常 (HTTP ${res.statusCode})`,
-          duration: Date.now() - startTime
-        });
-      });
-
-      req.on('error', (err) => {
-        resolve({
-          success: false,
-          message: `连接失败: ${err.message}`,
-          duration: Date.now() - startTime
-        });
-      });
+  const startTime = Date.now();
+  let client = null;
 
-      req.on('timeout', () => {
-        req.destroy();
-        resolve({
-          success: false,
-          message: '连接超时',
-          duration: timeout
-        });
-      });
+  try {
+    client = new McpClient(spec, { timeout: 10000 });
+    await client.connect();
+    await client.initialize();
 
-      req.end();
-    } catch (err) {
-      resolve({
-        success: false,
-        message: `URL 无效: ${err.message}`,
-        duration: Date.now() - startTime
-      });
+    return {
+      success: true,
+      message: '服务器 MCP 握手成功',
+      duration: Date.now() - startTime
+    };
+  } catch (err) {
+    const failure = buildMcpFailureResult(err, err.message, Date.now() - startTime);
+    return {
+      success: false,
+      message: failure.message,
+      hint: failure.hint,
+      duration: failure.duration
+    };
+  } finally {
+    if (client) {
+      try {
+        await client.disconnect();
+      } catch (err) {
+        // ignore cleanup failures
+      }
     }
-  });
+  }
 }
 
 /**