@atlisp/mcp 1.0.15 → 1.0.16

package/README.md

@@ -4,10 +4,6 @@ MCP (Model Context Protocol) Server for @lisp on CAD - 为 CAD 环境提供 @lis
 
 同时为 AI AGENT 操控 cad 提供调用工具和通道。
 
-## 版本
-
-**当前版本**: 1.0.10
-
 ## 功能特性
 
 - 连接 AutoCAD/ZWCAD/GStarCAD/BricsCAD

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@atlisp/mcp",
-    "version": "1.0.15",
+    "version": "1.0.16",
     "description": "MCP Server for @lisp on CAD",
     "type": "module",
     "bin": {
@@ -39,7 +39,9 @@
     "dependencies": {
         "@modelcontextprotocol/sdk": "^1.0.0",
         "edge-js": "^25.0.1",
-        "express": "^5.2.1"
+        "express": "^5.2.1",
+        "iconv-lite": "^0.6.3",
+        "raw-body": "^3.0.0"
     },
     "engines": {
         "node": ">=18.0.0"

package/src/atlisp-mcp.js

@@ -1,6 +1,8 @@
 import express from 'express';
+import rawBody from 'raw-body';
+import iconv from 'iconv-lite';
+const { decode: charsetDecode, encodingExists } = iconv;
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import {
     ListToolsRequestSchema,
@@ -18,7 +20,8 @@ import * as packageHandlers from './handlers/package-handlers.js';
 import * as functionHandlers from './handlers/function-handlers.js';
 import { listResources, readResource } from './handlers/resource-handlers.js';
 import * as subMgr from './subscription-manager.js';
-import { createSseResponseHandler } from './sse-utils.js';
+import { SseSession, SSE_EVENTS, createSseResponseHandler, parseLastEventId } from './sse-session.js';
+import { SseSessionManager } from './sse-session-manager.js';
 
 const PORT = process.env.PORT || 8110;
 const HOST = process.env.HOST || '0.0.0.0';
@@ -26,6 +29,8 @@ const TRANSPORT = process.env.TRANSPORT || 'http';
 const API_KEY = process.env.MCP_API_KEY || '';
 if (API_KEY) log('API Key authentication enabled');
 
+const sseSessionManager = new SseSessionManager();
+
 export { CAD_PLATFORMS, FILE_EXTENSIONS, MOCK_PACKAGES } from './constants.js';
 
 const TOOL_HANDLERS = {
@@ -239,6 +244,83 @@ export function createMcpServer() {
     return server;
 }
 
+async function handleMcpRequest(session, method, params, id) {
+    try {
+        if (method === 'initialize') {
+            session.sendResponse({ jsonrpc: '2.0', id, result: {
+                protocolVersion: PROTOCOL_VERSION,
+                capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } },
+                serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
+            } });
+            return;
+        }
+
+        if (method === 'tools/list') {
+            session.sendResponse({ jsonrpc: '2.0', id, result: { tools } });
+            return;
+        }
+
+        if (method === 'resources/list') {
+            const resources = await listResources(subMgr.list());
+            session.sendResponse({ jsonrpc: '2.0', id, result: { resources } });
+            return;
+        }
+
+        if (method === 'resources/read') {
+            const uri = params?.uri;
+            if (!uri) {
+                session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } });
+                return;
+            }
+            try {
+                const data = await readResource(uri);
+                session.sendResponse({ jsonrpc: '2.0', id, result: { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(data) }] } });
+            } catch (e) {
+                session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32603, message: e.message } });
+            }
+            return;
+        }
+
+        if (method === 'resources/subscribe') {
+            const uri = params?.uri;
+            if (!uri) {
+                session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } });
+                return;
+            }
+            subMgr.subscribe(uri);
+            session.sendResponse({ jsonrpc: '2.0', id, result: { success: true } });
+            return;
+        }
+
+        if (method === 'resources/unsubscribe') {
+            const uri = params?.uri;
+            if (!uri) {
+                session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } });
+                return;
+            }
+            subMgr.unsubscribe(uri);
+            session.sendResponse({ jsonrpc: '2.0', id, result: { success: true } });
+            return;
+        }
+
+        if (method === 'tools/call') {
+            const toolName = params?.name;
+            if (!toolName) {
+                session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32602, message: 'Invalid params: missing tool name' } });
+                return;
+            }
+            const result = await handleToolCall(toolName, params?.arguments || {});
+            session.sendResponse({ jsonrpc: '2.0', id, result });
+            return;
+        }
+
+        session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } });
+    } catch (e) {
+        log('MCP error: ' + e.message);
+        session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32603, message: e.message } });
+    }
+}
+
 export async function startServer() {
     if (TRANSPORT === 'stdio') {
         await initCadConnection();
@@ -248,7 +330,24 @@ export async function startServer() {
         console.error(`${SERVER_NAME} 运行在 stdio 模式`);
     } else {
         const app = express();
-        app.use(express.json({ type: ['application/json', 'application/json-rpc'] }));
+
+        const JSON_CONTENT_TYPES = ['application/json', 'application/json-rpc', 'application/vnd.api+json'];
+        app.use(async (req, res, next) => {
+            const ct = (req.headers['content-type'] || '').toLowerCase();
+            if (!JSON_CONTENT_TYPES.some(t => ct.startsWith(t))) return next();
+            try {
+                const buf = await rawBody(req, { limit: '10mb' });
+                const m = ct.match(/charset\s*=\s*([^\s;]+)/i);
+                let charset = m ? m[1].toLowerCase() : 'utf-8';
+                const charsetMap = { 'gb2312': 'gbk', 'gb18030': 'gbk', 'gbk': 'gbk', '936': 'gbk' };
+                charset = charsetMap[charset] || charset;
+                const str = encodingExists(charset) ? charsetDecode(buf, charset) : buf.toString('utf-8');
+                req.body = JSON.parse(str);
+                next();
+            } catch (e) {
+                res.status(400).json({ error: 'Invalid JSON body', message: e.message });
+            }
+        });
 
         app.use((req, res, next) => {
             log(`${req.method} ${req.path} - body: ${JSON.stringify(req.body)}`);
@@ -281,101 +380,148 @@ export async function startServer() {
 
         createMcpServer();
 
-        const sessionId = crypto.randomUUID();
+        app.get('/sse', (req, res) => {
+            const clientId = req.get('mcp-session-id') || req.get('Last-Event-ID') || crypto.randomUUID();
+            
+            const session = new SseSession(res, { clientId });
+            
+            session.sendEndpoint('/mcp');
+            session.sendCapabilities({
+                protocolVersion: PROTOCOL_VERSION,
+                capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } },
+                serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
+            });
+            
+            sseSessionManager.add(clientId, session);
+            
+            res.on('close', () => {
+                sseSessionManager.remove(clientId);
+            });
+        });
 
-        ['/sse', '/mcp/sse'].forEach(p => app.all(p, (req, res) => {
-            res.writeHead(200, { 'Content-Type': 'text/event-stream' });
-            const transport = new SSEServerTransport('/mcp', res);
-            server.connect(transport);
+        ['/mcp/sse'].forEach(p => app.all(p, (req, res) => {
+            const clientId = req.get('mcp-session-id') || req.get('Last-Event-ID') || crypto.randomUUID();
+            
+            const session = new SseSession(res, { clientId });
+            
+            session.sendEndpoint('/mcp');
+            session.sendCapabilities({
+                protocolVersion: PROTOCOL_VERSION,
+                capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } },
+                serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
+            });
+            
+            sseSessionManager.add(clientId, session);
+            
+            res.on('close', () => {
+                sseSessionManager.remove(clientId);
+            });
         }));
 
-	app.post('/mcp', async (req, res) => {
-	    const body = req.body || {};
-	    const { method, params, id } = body;
-	    const accept = req.get('Accept') || '';
-	    const wantsSse = accept.includes('text/event-stream');
-	    log('accept: "' + accept + '", wantsSSE: ' + wantsSse);
-
-	    res.setHeader('mcp-session-id', sessionId);
-	    const { send } = createSseResponseHandler(res, wantsSse);
-
-	    if (!id) return res.status(204).end();
-
-	    try {
-		if (method === 'initialize') {
-		    send({ jsonrpc: '2.0', id, result: {
-			protocolVersion: PROTOCOL_VERSION,
-			capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } },
-			serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
-		    } }, true);
-		    return;
-		}
-
-		if (method === 'tools/list') {
-		    send({ jsonrpc: '2.0', id, result: { tools } }, true);
-		    return;
-		}
-
-		if (method === 'resources/list') {
-		    const resources = await listResources(subMgr.list());
-		    send({ jsonrpc: '2.0', id, result: { resources } }, true);
-		    return;
-		}
-
-		if (method === 'resources/read') {
-		    const uri = params?.uri;
-		    if (!uri) {
-			send({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } }, true);
-			return;
-		    }
-		    try {
-			const data = await readResource(uri);
-			send({ jsonrpc: '2.0', id, result: { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(data) }] } }, true);
-		    } catch (e) {
-			send({ jsonrpc: '2.0', id, error: { code: -32603, message: e.message } }, true);
-		    }
-		    return;
-		}
-
-		if (method === 'resources/subscribe') {
-		    const uri = params?.uri;
-		    if (!uri) {
-			send({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } }, true);
-			return;
-		    }
-		    subMgr.subscribe(uri);
-		    send({ jsonrpc: '2.0', id, result: { success: true } }, true);
-		    return;
-		}
-
-		if (method === 'resources/unsubscribe') {
-		    const uri = params?.uri;
-		    if (!uri) {
-			send({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } }, true);
-			return;
-		    }
-		    subMgr.unsubscribe(uri);
-		    send({ jsonrpc: '2.0', id, result: { success: true } }, true);
-		    return;
-		}
-
-		if (method === 'tools/call') {
-		    const toolName = params?.name;
-		    if (!toolName) {
-			send({ jsonrpc: '2.0', id, error: { code: -32602, message: 'Invalid params: missing tool name' } }, true);
-			return;
-		    }
-		    const result = await handleToolCall(toolName, params?.arguments || {});
-		    send({ jsonrpc: '2.0', id, result }, true);
-		    return;
-		}
-
-		send({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } }, true);
-	    } catch (e) {
-		log('MCP error: ' + e.message);
-		send({ jsonrpc: '2.0', id, error: { code: -32603, message: e.message } }, true);
-	    }
-	});
+        app.post('/mcp', async (req, res) => {
+            const body = req.body || {};
+            const { method, params, id } = body;
+            const accept = req.get('Accept') || '';
+            const wantsSse = accept.includes('text/event-stream');
+            const sessionId = req.get('mcp-session-id') || '';
+            log(`${req.method} ${req.path} - session: ${sessionId} - method: ${method} - wantsSSE: ${wantsSse}`);
+
+            if (wantsSse) {
+                res.setHeader('Content-Type', 'text/event-stream');
+                res.setHeader('Cache-Control', 'no-cache');
+                res.setHeader('Connection', 'keep-alive');
+                
+                if (sessionId && sseSessionManager.has(sessionId)) {
+                    const session = sseSessionManager.get(sessionId);
+                    if (!id) {
+                        res.status(204).end();
+                        return;
+                    }
+                    await handleMcpRequest(session, method, params, id);
+                    return;
+                }
+            }
+
+            res.setHeader('mcp-session-id', sessionId || crypto.randomUUID());
+            const { send } = createSseResponseHandler(res, wantsSse);
+
+            if (!id) return res.status(204).end();
+
+            try {
+                if (method === 'initialize') {
+                    send({ jsonrpc: '2.0', id, result: {
+                        protocolVersion: PROTOCOL_VERSION,
+                        capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } },
+                        serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
+                    } }, true);
+                    return;
+                }
+
+                if (method === 'tools/list') {
+                    send({ jsonrpc: '2.0', id, result: { tools } }, true);
+                    return;
+                }
+
+                if (method === 'resources/list') {
+                    const resources = await listResources(subMgr.list());
+                    send({ jsonrpc: '2.0', id, result: { resources } }, true);
+                    return;
+                }
+
+                if (method === 'resources/read') {
+                    const uri = params?.uri;
+                    if (!uri) {
+                        send({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } }, true);
+                        return;
+                    }
+                    try {
+                        const data = await readResource(uri);
+                        send({ jsonrpc: '2.0', id, result: { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(data) }] } }, true);
+                    } catch (e) {
+                        send({ jsonrpc: '2.0', id, error: { code: -32603, message: e.message } }, true);
+                    }
+                    return;
+                }
+
+                if (method === 'resources/subscribe') {
+                    const uri = params?.uri;
+                    if (!uri) {
+                        send({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } }, true);
+                        return;
+                    }
+                    subMgr.subscribe(uri);
+                    send({ jsonrpc: '2.0', id, result: { success: true } }, true);
+                    return;
+                }
+
+                if (method === 'resources/unsubscribe') {
+                    const uri = params?.uri;
+                    if (!uri) {
+                        send({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } }, true);
+                        return;
+                    }
+                    subMgr.unsubscribe(uri);
+                    send({ jsonrpc: '2.0', id, result: { success: true } }, true);
+                    return;
+                }
+
+                if (method === 'tools/call') {
+                    const toolName = params?.name;
+                    if (!toolName) {
+                        send({ jsonrpc: '2.0', id, error: { code: -32602, message: 'Invalid params: missing tool name' } }, true);
+                        return;
+                    }
+                    const result = await handleToolCall(toolName, params?.arguments || {});
+                    send({ jsonrpc: '2.0', id, result }, true);
+                    return;
+                }
+
+                send({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } }, true);
+            } catch (e) {
+                log('MCP error: ' + e.message);
+                send({ jsonrpc: '2.0', id, error: { code: -32603, message: e.message } }, true);
+            }
+        });
 
 	app.listen(PORT, HOST, async () => {
 	    await initCadConnection();

package/src/cad-worker.js

@@ -1,10 +1,19 @@
 #!/usr/bin/env node
 import edge from 'edge-js';
 import process from 'process';
+import fs from 'fs';
+import path from 'path';
 
 const BUSY_RETRIES = parseInt(process.env.BUSY_RETRIES || '10', 10);
 const BUSY_DELAY = parseInt(process.env.BUSY_DELAY || '500', 10);
 
+const DEBUG_FILE = process.env.DEBUG_FILE || path.join(process.env.TEMP || '/tmp', 'cad-worker-debug.log');
+
+function log(msg) {
+    const entry = `${new Date().toISOString()} ${msg}\n`;
+    fs.appendFileSync(DEBUG_FILE, entry);
+}
+
 const cadConnect = edge.func(function() {/*
   async (input) => {
       try {
@@ -111,19 +120,33 @@ const cadSend = edge.func(function() {/*
 const cadSendWithResult = edge.func(function() {/*
   async (input) => {
       string tempFile = null;
+      string lispFile = null;
       try {
           dynamic d = input;
           string code = d.code.ToString();
           string platform = d.platform.ToString();
+          string encoding = d.encoding != null ? d.encoding.ToString() : "";
           string progId = platform + ".Application";
-          string tempDir = System.IO.Path.GetTempPath();
+          string tempDir = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "@lisp");
+          System.IO.Directory.CreateDirectory(tempDir);
+          
           tempFile = System.IO.Path.Combine(tempDir, "atlisp_result_" + System.Guid.NewGuid().ToString("N") + ".txt");
-          string lispCode = "(progn(setq f(open \"" + tempFile.Replace("\\", "\\\\") + "\" \"w\"))(print " + code + " f)(close f)(princ))";
+          lispFile = System.IO.Path.Combine(tempDir, "atlisp_code_" + System.Guid.NewGuid().ToString("N") + ".lsp");
+          
+          // 生成 LISP 代码：执行 code，将结果打印到 tempFile
+          // 使用 princ 输出原始字符串
+          string lispCode = "(progn(setq f(open \"" + tempFile.Replace("\\", "\\\\") + "\" \"w\"))(princ " + code + " f)(close f)(princ))";
+          
+            // 使用系统 ANSI 编码以兼容 GstarCAD / ZWCAD
+            System.IO.File.WriteAllText(lispFile, lispCode, System.Text.Encoding.GetEncoding(System.Globalization.CultureInfo.CurrentCulture.TextInfo.ANSICodePage));
+          
           dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject(progId);
           if (cad != null) {
               dynamic doc = cad.ActiveDocument;
               if (doc != null) {
-                  doc.SendCommand(lispCode + "\n");
+                  // 加载 .lsp 文件执行
+                  doc.SendCommand("(load \"" + lispFile.Replace("\\", "\\\\") + "\")\n");
+                  
                   int retries = 10;
                   string result = "";
                   while (retries > 0 && !System.IO.File.Exists(tempFile)) {
@@ -135,8 +158,33 @@ const cadSendWithResult = edge.func(function() {/*
                       while (retries > 0) {
                           try {
                               byte[] bytes = System.IO.File.ReadAllBytes(tempFile);
-                              result = System.Text.Encoding.GetEncoding("GBK").GetString(bytes).Trim();
+                              System.Text.Encoding enc;
+                              
+                              // 优先使用指定的编码
+                              if (!string.IsNullOrEmpty(encoding)) {
+                                  enc = System.Text.Encoding.GetEncoding(encoding);
+                              } else {
+                                  // 自动检测编码：先尝试 UTF-8，如果失败则使用 GBK
+                                  try {
+                                      string utf8Result = System.Text.Encoding.UTF8.GetString(bytes);
+                                      if (!utf8Result.Contains("\ufffd")) {
+                                          enc = System.Text.Encoding.UTF8;
+                                      } else {
+                                          enc = System.Text.Encoding.GetEncoding("gbk");
+                                      }
+                                  } catch {
+                                      try {
+                                          enc = System.Text.Encoding.GetEncoding("gbk");
+                                      } catch {
+                                          enc = System.Text.Encoding.Default;
+                                      }
+                                  }
+                              }
+                              
+                              result = enc.GetString(bytes).Trim();
+                              
                               try { System.IO.File.Delete(tempFile); } catch {}
+                              try { System.IO.File.Delete(lispFile); } catch {}
                               break;
                           } catch (System.IO.IOException) {
                               System.Threading.Thread.Sleep(200);
@@ -156,11 +204,17 @@ const cadSendWithResult = edge.func(function() {/*
           if (tempFile != null) {
               try { if (System.IO.File.Exists(tempFile)) System.IO.File.Delete(tempFile); } catch {}
           }
+          if (lispFile != null) {
+              try { if (System.IO.File.Exists(lispFile)) System.IO.File.Delete(lispFile); } catch {}
+          }
           return new { success = false, error = ex.Message };
       }
       if (tempFile != null) {
           try { if (System.IO.File.Exists(tempFile)) System.IO.File.Delete(tempFile); } catch {}
       }
+      if (lispFile != null) {
+          try { if (System.IO.File.Exists(lispFile)) System.IO.File.Delete(lispFile); } catch {}
+      }
       return new { success = false };
   }
   */});
@@ -343,10 +397,16 @@ async function handleMessage(msg) {
     if (!(await waitForIdle(msg.platform))) {
       return { success: false, error: 'CAD is busy, timeout' };
     }
+    log(`send: ${msg.code}`);
     return new Promise((resolve, reject) => {
       cadSend({ code: msg.code, platform: msg.platform }, (e, r) => {
-        if (e) reject(e);
-        else resolve(r);
+        if (e) {
+          log(`send error: ${e.message}`);
+          reject(e);
+        } else {
+          log(`send result: ${JSON.stringify(r)}`);
+          resolve(r);
+        }
       });
     });
   }
@@ -367,10 +427,16 @@ async function handleMessage(msg) {
     if (!(await waitForIdle(msg.platform))) {
       return { success: false, error: 'CAD is busy, timeout' };
     }
+    log(`sendResult: ${msg.code}`);
     return new Promise((resolve, reject) => {
-      cadSendWithResult({ code: msg.code, platform: msg.platform }, (e, r) => {
-        if (e) reject(e);
-        else resolve(r);
+      cadSendWithResult({ code: msg.code, platform: msg.platform, encoding: msg.encoding || '' }, (e, r) => {
+        if (e) {
+          log(`sendResult error: ${e.message}`);
+          reject(e);
+        } else {
+          log(`sendResult result: ${JSON.stringify(r)}`);
+          resolve(r);
+        }
       });
     });
   }

package/src/cad.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'url';
 import { CAD_PLATFORMS, FILE_EXTENSIONS } from './constants.js';
 
 const MESSAGE_TIMEOUT = parseInt(process.env.MESSAGE_TIMEOUT || '60000', 10);
+const RESULT_ENCODING = process.env.RESULT_ENCODING || '';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const workerPath = path.join(__dirname, 'cad-worker.js');
@@ -37,9 +38,11 @@ export function getWorker() {
     worker.connected = true;
     
     worker.stderr.on('data', (d) => console.error('worker stderr:', d.toString()));
-    worker.on('exit', (code) => {
+    const w = worker;
+    w.on('exit', (code) => {
       console.error('worker exited:', code);
-      worker.connected = false;
+      if (w !== worker) return;
+      w.connected = false;
       if (heartbeatTimer) {
         clearInterval(heartbeatTimer);
         heartbeatTimer = null;
@@ -138,26 +141,18 @@ class CadConnection {
 
   async sendCommand(code) {
     if (!this.connected) throw new Error('未连接 CAD');
-    try {
-      const result = await sendMessage({ type: 'send', code: code, platform: _platform });
-      if (result.success) return true;
-      throw new Error(result.error || '发送失败');
-    } catch (e) {
-      throw e;
-    }
+    const result = await sendMessage({ type: 'send', code: code, platform: _platform });
+    if (result.success) return true;
+    throw new Error(result.error || '发送失败');
   }
 
   async sendCommandWithResult(code) {
     if (!this.connected) throw new Error('未连接 CAD');
-    try {
-      const result = await sendMessage({ type: 'sendResult', code: code, platform: _platform });
-      if (result.success) {
-        return result.result || '';
-      }
-      throw new Error(result.error || '发送失败');
-    } catch (e) {
-      throw e;
+    const result = await sendMessage({ type: 'sendResult', code: code, platform: _platform, encoding: RESULT_ENCODING });
+    if (result.success) {
+      return result.result || '';
     }
+    throw new Error(result.error || '发送失败');
   }
 
   getVersion() { return this.version; }

package/src/constants.js

@@ -7,7 +7,7 @@ export const FILE_EXTENSIONS = {
 
 export const PROTOCOL_VERSION = '2024-11-05';
 export const SERVER_NAME = 'atlisp-mcp-server';
-export const SERVER_VERSION = '1.0.13';
+export const SERVER_VERSION = '1.0.16';
 
 export const MOCK_PACKAGES = [
     { name: 'base', description: '基础函数库', version: '1.0.0' },

package/src/sse-session-manager.js

@@ -0,0 +1,135 @@
+import { SseSession, SSE_EVENTS } from './sse-session.js';
+
+export class SseSessionManager {
+    #sessions = new Map();
+    #eventHandlers = new Map();
+
+    constructor() {
+        this.#sessions = new Map();
+        this.#eventHandlers = new Map();
+    }
+
+    add(clientId, session) {
+        if (!(session instanceof SseSession)) {
+            throw new Error('session must be an SseSession instance');
+        }
+        this.#sessions.set(clientId, session);
+        session.startHeartbeat();
+    }
+
+    remove(clientId) {
+        const session = this.#sessions.get(clientId);
+        if (session) {
+            session.close();
+            this.#sessions.delete(clientId);
+            return true;
+        }
+        return false;
+    }
+
+    get(clientId) {
+        return this.#sessions.get(clientId) || null;
+    }
+
+    has(clientId) {
+        return this.#sessions.has(clientId);
+    }
+
+    list() {
+        return Array.from(this.#sessions.keys()).map(id => ({
+            clientId: id,
+            isActive: this.#sessions.get(id)?.isActive ?? false
+        }));
+    }
+
+    listActive() {
+        return this.list().filter(s => s.isActive);
+    }
+
+    count() {
+        return this.#sessions.size;
+    }
+
+    sendToClient(clientId, event, data, id = null) {
+        const session = this.#sessions.get(clientId);
+        if (!session || !session.isActive) {
+            return false;
+        }
+        return session.sendEvent(event, data, id);
+    }
+
+    sendMessageToClient(clientId, data) {
+        return this.sendToClient(clientId, SSE_EVENTS.MESSAGE, data);
+    }
+
+    sendErrorToClient(clientId, code, message, id = null) {
+        return this.sendToClient(clientId, SSE_EVENTS.ERROR, { code, message }, id);
+    }
+
+    sendProgressToClient(clientId, current, total, message = '') {
+        return this.sendToClient(clientId, SSE_EVENTS.PROGRESS, { current, total, message });
+    }
+
+    broadcast(event, data) {
+        let successCount = 0;
+        for (const [clientId, session] of this.#sessions) {
+            if (session.isActive && session.sendEvent(event, data)) {
+                successCount++;
+            }
+        }
+        return successCount;
+    }
+
+    broadcastMessage(data) {
+        return this.broadcast(SSE_EVENTS.MESSAGE, data);
+    }
+
+    broadcastError(code, message) {
+        return this.broadcast(SSE_EVENTS.ERROR, { code, message });
+    }
+
+    on(event, handler) {
+        if (!this.#eventHandlers.has(event)) {
+            this.#eventHandlers.set(event, new Set());
+        }
+        this.#eventHandlers.get(event).add(handler);
+    }
+
+    off(event, handler) {
+        const handlers = this.#eventHandlers.get(event);
+        if (handlers) {
+            handlers.delete(handler);
+        }
+    }
+
+    emit(event, data) {
+        const handlers = this.#eventHandlers.get(event);
+        if (handlers) {
+            for (const handler of handlers) {
+                try {
+                    handler(data);
+                } catch (e) {
+                    // Ignore handler errors
+                }
+            }
+        }
+    }
+
+    cleanupInactive() {
+        for (const [clientId, session] of this.#sessions) {
+            if (!session.isActive) {
+                session.close();
+                this.#sessions.delete(clientId);
+            }
+        }
+    }
+
+    closeAll() {
+        for (const [clientId, session] of this.#sessions) {
+            session.close();
+        }
+        this.#sessions.clear();
+    }
+}
+
+export const globalSessionManager = new SseSessionManager();

package/src/sse-session.js

@@ -0,0 +1,204 @@
+import { randomUUID } from 'crypto';
+
+const DEFAULT_HEARTBEAT_INTERVAL = 30000;
+const RECONNECT_DELAY = 5000;
+
+export const SSE_EVENTS = {
+    MESSAGE: 'message',
+    ENDPOINT: 'endpoint',
+    PING: 'ping',
+    ERROR: 'error',
+    PROGRESS: 'progress',
+    CAPABILITIES: 'capabilities',
+};
+
+export class SseSession {
+    #res;
+    #clientId;
+    #active = true;
+    #heartbeatTimer = null;
+    #lastEventId = 0;
+    #heartbeatInterval;
+    #sessionData = {};
+
+    constructor(res, options = {}) {
+        this.#res = res;
+        this.#clientId = options.clientId || randomUUID();
+        this.#heartbeatInterval = options.heartbeatInterval || DEFAULT_HEARTBEAT_INTERVAL;
+        this.#sessionData = options.sessionData || {};
+
+        this._setupSseHeaders();
+    }
+
+    get clientId() {
+        return this.#clientId;
+    }
+
+    get isActive() {
+        return this.#active;
+    }
+
+    get sessionData() {
+        return this.#sessionData;
+    }
+
+    setSessionData(key, value) {
+        this.#sessionData[key] = value;
+    }
+
+    getSessionData(key) {
+        return this.#sessionData[key];
+    }
+
+    _setupSseHeaders() {
+        this.#res.setHeader('Content-Type', 'text/event-stream');
+        this.#res.setHeader('Cache-Control', 'no-cache');
+        this.#res.setHeader('Connection', 'keep-alive');
+        this.#res.setHeader('Transfer-Encoding', 'chunked');
+        this.#res.setHeader('X-Accel-Buffering', 'no');
+    }
+
+    _formatEvent(event, data, id = null) {
+        let lines = [];
+        if (id !== null) {
+            lines.push(`id: ${id}`);
+        }
+        lines.push(`event: ${event}`);
+        
+        const jsonStr = JSON.stringify(data);
+        lines.push(`data: ${jsonStr}`);
+        
+        return lines.join('\n') + '\n\n';
+    }
+
+    _write(content) {
+        if (!this.#active) return false;
+        try {
+            const result = this.#res.write(content);
+            if (typeof this.#res.flush === 'function') {
+                this.#res.flush();
+            }
+            if (result === false) {
+                this.#active = false;
+                return false;
+            }
+            return true;
+        } catch (e) {
+            this.#active = false;
+            return false;
+        }
+    }
+
+    sendEvent(event, data, id = null) {
+        this.#lastEventId++;
+        const eventId = id !== null ? id : this.#lastEventId;
+        return this._write(this._formatEvent(event, data, eventId));
+    }
+
+    sendMessage(data) {
+        return this.sendEvent(SSE_EVENTS.MESSAGE, data);
+    }
+
+    sendEndpoint(path) {
+        return this.sendEvent(SSE_EVENTS.ENDPOINT, { path });
+    }
+
+    sendError(code, message, id = null) {
+        return this.sendEvent(SSE_EVENTS.ERROR, { code, message }, id);
+    }
+
+    sendPing() {
+        return this.sendEvent(SSE_EVENTS.PING, { timestamp: Date.now() });
+    }
+
+    sendProgress(current, total, message = '') {
+        return this.sendEvent(SSE_EVENTS.PROGRESS, { current, total, message });
+    }
+
+    sendCapabilities(capabilities) {
+        return this.sendEvent(SSE_EVENTS.CAPABILITIES, capabilities);
+    }
+
+    sendResponse(jsonrpcResponse, id = null) {
+        const eventId = id !== null ? id : this.#lastEventId;
+        return this.sendEvent(SSE_EVENTS.MESSAGE, jsonrpcResponse, eventId);
+    }
+
+    startHeartbeat(interval = null) {
+        this.stopHeartbeat();
+        const ms = interval || this.#heartbeatInterval;
+        
+        this.#heartbeatTimer = setInterval(() => {
+            if (!this.#active) {
+                this.stopHeartbeat();
+                return;
+            }
+            if (!this.sendPing()) {
+                this.stopHeartbeat();
+                this.close();
+            }
+        }, ms);
+    }
+
+    stopHeartbeat() {
+        if (this.#heartbeatTimer) {
+            clearInterval(this.#heartbeatTimer);
+            this.#heartbeatTimer = null;
+        }
+    }
+
+    close() {
+        this.#active = false;
+        this.stopHeartbeat();
+        try {
+            this.#res.end();
+        } catch (e) {
+            // Ignore errors during close
+        }
+    }
+}
+
+export function setupSseHeaders(res) {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('Transfer-Encoding', 'chunked');
+}
+
+export function sendSSE(res, data, event = SSE_EVENTS.MESSAGE) {
+    const lines = [
+        `event: ${event}`,
+        `data: ${JSON.stringify(data)}`,
+        ''
+    ];
+    res.write(lines.join('\n') + '\n');
+    if (typeof res.flush === 'function') res.flush();
+}
+
+export function createSseResponseHandler(res, acceptSse = false) {
+    if (acceptSse) {
+        setupSseHeaders(res);
+    }
+
+    return {
+        send: (data, done = false) => {
+            const json = JSON.stringify(data);
+            if (acceptSse) {
+                sendSSE(res, data);
+                if (done) res.end();
+            } else {
+                res.setHeader('Content-Type', 'application/json');
+                res.end(json);
+            }
+        }
+    };
+}
+
+export function parseLastEventId(req) {
+    const lastEventId = req.get('Last-Event-ID') || req.get('last-event-id');
+    if (lastEventId) {
+        const parsed = parseInt(lastEventId, 10);
+        return isNaN(parsed) ? null : parsed;
+    }
+    return null;
+}

package/src/sse-utils.js

@@ -1,32 +0,0 @@
-export function setupSseHeaders(res) {
-    res.setHeader('Content-Type', 'text/event-stream');
-    res.setHeader('Cache-Control', 'no-cache');
-    res.setHeader('Connection', 'keep-alive');
-    res.setHeader('Transfer-Encoding', 'chunked');
-}
-
-export function sendSSE(res, data, event = 'message') {
-    const json = JSON.stringify(data);
-    res.write(`event: ${event}\n`);
-    res.write(`data: ${json}\n\n`);
-    if (typeof res.flush === 'function') res.flush();
-}
-
-export function createSseResponseHandler(res, acceptSse = false) {
-    if (acceptSse) {
-        setupSseHeaders(res);
-    }
-
-    return {
-        send: (data, done = false) => {
-            const json = JSON.stringify(data);
-            if (acceptSse) {
-                sendSSE(res, data);
-                if (done) res.end();
-            } else {
-                res.setHeader('Content-Type', 'application/json');
-                res.end(json);
-            }
-        }
-    };
-}