@atlisp/mcp 1.1.3 → 1.2.0

package/README.md

@@ -254,6 +254,7 @@ curl http://localhost:8110/health
 | `install_atlisp` | 安装 @lisp | 无 |
 | `get_function_usage` | 获取函数用法 | `name`: 函数名 |
 | `list_functions` | 列出所有函数 | 无 |
+| `load_atlisp_functionlib` | 从网络加载函数库（AI 提示词/编程） | `format`: json/list |
 
 ### MCP 方法
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@atlisp/mcp",
-    "version": "1.1.3",
+    "version": "1.2.0",
     "description": "MCP Server for @lisp on CAD",
     "type": "module",
     "bin": {

package/src/atlisp-mcp.js

@@ -55,11 +55,11 @@ import rawBody from 'raw-body';
 import iconv from 'iconv-lite';
 import rateLimit from 'express-rate-limit';
 import { randomUUID } from 'crypto';
+import { AsyncLocalStorage } from 'async_hooks';
 const { decode: charsetDecode, encodingExists } = iconv;
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { SessionTransport } from './session-transport.js';
 import {
     ListToolsRequestSchema,
     CallToolRequestSchema,
@@ -79,9 +79,14 @@ import * as functionHandlers from './handlers/function-handlers.js';
 import { listResources, readResource } from './handlers/resource-handlers.js';
 import { listPrompts, getPrompt } from './handlers/prompt-handlers.js';
 import * as subMgr from './subscription-manager.js';
-import { createError, toMcpError } from './errors.js';
+import { sessionManager } from './subscription-manager.js';
+import { SseSessionManager } from './sse-session-manager.js';
+import { SseSession } from './sse-session.js';
 import config from './config.js';
 
+const mcpContext = new AsyncLocalStorage();
+const sseSessionManager = new SseSessionManager();
+
 const SERVER_CAPABILITIES = {
     tools: {},
     resources: { subscribe: true, listChanged: true },
@@ -108,6 +113,30 @@ const mcpLimiter = rateLimit({
 
 export { CAD_PLATFORMS, FILE_EXTENSIONS, MOCK_PACKAGES } from './constants.js';
 
+const FUNCTION_LIB_URL = process.env.FUNCTION_LIB_URL || 'http://s3.atlisp.cn/json/functions.json';
+let cachedFunctionLib = null;
+let cachedAt = null;
+const CACHE_TTL = 5 * 60 * 1000;
+
+export async function loadAtlibFunctionLib() {
+    const now = Date.now();
+    if (cachedFunctionLib && cachedAt && (now - cachedAt) < CACHE_TTL) {
+        return cachedFunctionLib;
+    }
+    try {
+        const response = await fetch(FUNCTION_LIB_URL, { headers: { 'User-Agent': 'atlisp-mcp' } });
+        if (response.ok) {
+            const data = await response.json();
+            cachedFunctionLib = data;
+            cachedAt = now;
+            return data;
+        }
+    } catch (e) {
+        log(`loadAtlibFunctionLib error: ${e.message}`);
+    }
+    return null;
+}
+
 const TOOL_HANDLERS = {
     connect_cad:           () => cadHandlers.connectCad(),
     eval_lisp:             (a) => cadHandlers.evalLisp(a.code),
@@ -124,19 +153,48 @@ const TOOL_HANDLERS = {
     init_atlisp:          () => cadHandlers.initAtlisp(),
     get_function_usage:    (a) => functionHandlers.getFunctionUsage(a.name, a.package),
     list_functions:        (a) => functionHandlers.listFunctions(a.package),
-    get_file_extensions:  (a) => {
-        const exts = FILE_EXTENSIONS[a.platform];
-        if (!exts) return { content: [{ type: 'text', text: `平台 ${a.platform} 不支持` }], isError: true };
-        return { content: [{ type: 'text', text: `${a.platform} 文件扩展名: ${exts.join(', ')}` }] };
+    load_atlisp_functionlib: async (a) => {
+        const data = await loadAtlibFunctionLib();
+        if (!data) return { content: [{ type: 'text', text: '加载函数库失败' }], isError: true };
+        if (a.format === 'list') {
+            const items = data.functions?.map(f => `${f.name}: ${f.description || ''}`) || [];
+            return { content: [{ type: 'text', text: items.join('\n') }] };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
     },
-    get_install_code:     () => ({
-        content: [{
-            type: 'text',
-            text: `复制以下代码到 CAD 命令行加载:\n(load "atlisp" "atlisp")\n(vlax-create-object "atlisp.atlisp.1")`
-        }]
-    }),
 };
 
+function getOrCreateSessionServer(sessionId) {
+  let entry = sessionServers.get(sessionId);
+  if (!entry) {
+    const server = createMcpServer();
+    const transport = new SessionTransport(sessionId);
+    server.connect(transport);
+    entry = { server, transport };
+    sessionServers.set(sessionId, entry);
+    sessionTranports.set(sessionId, transport);
+  }
+  return entry;
+}
+
+function removeSessionServer(sessionId) {
+  const entry = sessionServers.get(sessionId);
+  if (entry) {
+    entry.transport.close().catch(() => {});
+    entry.server.close().catch(() => {});
+    sessionServers.delete(sessionId);
+    sessionTranports.delete(sessionId);
+  }
+}
+
+function broadcastToAllSessions(uri) {
+  for (const [sid, entry] of sessionServers) {
+    entry.server.sendResourceUpdated({ uri }).catch(err => {
+      log(`Failed to send resource update to session ${sid}: ${err.message}`);
+    });
+  }
+}
+
 export const tools = [
     {
 	name: 'connect_cad',
@@ -228,7 +286,7 @@ export const tools = [
     },
     {
 	name: 'get_function_usage',
-	description: '获取 @lisp 函数用法（从本地 JSON 库）',
+	description: '获取 @lisp 函数用法',
 	inputSchema: {
 	    type: 'object',
 	    properties: {
@@ -249,20 +307,14 @@ export const tools = [
 	}
     },
     {
-	name: 'get_file_extensions',
-	description: '获取 CAD 平台对应的文件扩展名',
+	name: 'load_atlisp_functionlib',
+	description: '从 http://s3.atlisp.cn/json/functions.json 加载 @lisp 函数库（用于 AI Agent 的提示词和编程调用）',
 	inputSchema: {
 	    type: 'object',
 	    properties: {
-		platform: { type: 'string', description: 'CAD 平台，如 AutoCAD, ZWCAD, GStarCAD, BricsCAD' }
-	    },
-	    required: ['platform']
+		format: { type: 'string', enum: ['json', 'list'], description: '返回格式：json（完整JSON）或 list（函数名:描述 列表），默认 json' }
+	    }
 	}
-    },
-    {
-	name: 'get_install_code',
-	description: '获取 @lisp 安装代码',
-	inputSchema: { type: 'object', properties: {} }
     }
 ];
 
@@ -311,10 +363,11 @@ async function initCadConnection() {
     }
 }
 
-let server = null;
+const sessionServers = new Map();
+const sessionTranports = new Map();
 
 export function createMcpServer() {
-    server = new Server(
+    const server = new Server(
 	{ name: SERVER_NAME, version: SERVER_VERSION },
 	{ capabilities: SERVER_CAPABILITIES }
     );
@@ -326,9 +379,14 @@ export function createMcpServer() {
 	return await handleToolCall(name, args || {});
     });
 
-    server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-        resources: await listResources(subMgr.list())
-    }));
+    server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
+        const ctx = mcpContext.getStore();
+        const sessionId = ctx?.sessionId;
+        const subscribedUris = sessionId ? subMgr.list(sessionId) : subMgr.list();
+        return {
+            resources: await listResources(subscribedUris)
+        };
+    });
 
     server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
         const { uri } = request.params;
@@ -352,13 +410,15 @@ export function createMcpServer() {
 
     server.setRequestHandler(SubscribeRequestSchema, async (request) => {
         const { uri } = request.params;
-        subMgr.subscribe(uri);
+        const ctx = mcpContext.getStore();
+        subMgr.subscribe(uri, ctx?.sessionId);
         return { success: true };
     });
 
     server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
         const { uri } = request.params;
-        subMgr.unsubscribe(uri);
+        const ctx = mcpContext.getStore();
+        subMgr.unsubscribe(uri, ctx?.sessionId);
         return { success: true };
     });
 
@@ -374,74 +434,18 @@ export function createMcpServer() {
     return server;
 }
 
-async function dispatchMcpMethod(responder, method, params, id) {
-    try {
-        if (method === 'initialize') {
-            responder({ jsonrpc: '2.0', id, result: SERVER_INFO });
-            return;
-        }
-
-        const methodHandlers = {
-            'tools/list': async () => ({ tools }),
-            'resources/list': async () => ({ resources: await listResources(subMgr.list()) }),
-            'resources/read': async () => {
-                const uri = params?.uri;
-                if (!uri) throw createError('INVALID_PARAMS', { detail: '缺少 uri 参数' });
-                const data = await readResource(uri);
-                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(data) }] };
-            },
-            'resources/subscribe': async () => {
-                const uri = params?.uri;
-                if (!uri) throw createError('INVALID_PARAMS', { detail: '缺少 uri 参数' });
-                subMgr.subscribe(uri);
-                return { success: true };
-            },
-            'resources/unsubscribe': async () => {
-                const uri = params?.uri;
-                if (!uri) throw createError('INVALID_PARAMS', { detail: '缺少 uri 参数' });
-                subMgr.unsubscribe(uri);
-                return { success: true };
-            },
-            'tools/call': async () => {
-                const toolName = params?.name;
-                if (!toolName) throw createError('INVALID_PARAMS', { detail: 'missing tool name' });
-                return await handleToolCall(toolName, params?.arguments || {});
-            },
-            'prompts/list': async () => ({ prompts: await listPrompts() }),
-            'prompts/get': async () => {
-                const promptName = params?.name;
-                if (!promptName) throw createError('INVALID_PARAMS', { detail: '缺少 prompt name 参数' });
-                return await getPrompt(promptName, params?.arguments || {});
-            }
-        };
-
-        const handler = methodHandlers[method];
-        if (handler) {
-            const result = await handler();
-            responder({ jsonrpc: '2.0', id, result });
-        } else {
-            responder({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } });
-        }
-    } catch (e) {
-        const mcpError = toMcpError(e);
-        log(`MCP error [${method}]: ${mcpError.message}`);
-        responder({ jsonrpc: '2.0', id, error: { code: -32603, message: mcpError.message } });
-    }
-}
 
-async function handleMcpRequest(session, method, params, id) {
-    await dispatchMcpMethod(
-        (response) => session.sendResponse(response),
-        method, params, id
-    );
-}
 
 export async function startServer() {
     if (config.transport === 'stdio') {
         await initCadConnection();
         const mcpServer = createMcpServer();
         const transport = new StdioServerTransport();
-        await mcpServer.connect(transport);
+        const sessionId = 'stdio-session';
+        sessionManager.createSession(sessionId);
+        await mcpContext.run({ sessionId }, async () => {
+            await mcpServer.connect(transport);
+        });
         console.error(`${SERVER_NAME} 运行在 stdio 模式`);
 
         subMgr.setNotify((uri, data) => {
@@ -502,129 +506,115 @@ export async function startServer() {
             });
         }
 
-        const mcpServer = createMcpServer();
-
-        const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: () => randomUUID(),
-        });
-
-        await mcpServer.connect(transport);
-        log('MCP Server connected to StreamableHTTPServerTransport');
-
         subMgr.setNotify((uri, data) => {
-            mcpServer.sendResourceUpdated({ uri }).catch(err => {
-                log(`Failed to send resource update: ${err.message}`);
-            });
+            broadcastToAllSessions(uri);
+            for (const session of sseSessionManager.listActive()) {
+                sseSessionManager.sendToClient(session.clientId, 'resource_updated', { uri });
+            }
         });
 
-        app.all('/mcp', mcpLimiter, async (req, res) => {
-            try {
-                await transport.handleRequest(req, res, req.body);
-            } catch (error) {
-                log(`Transport error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
+        async function handleMcpPost(req, res) {
+            const sessionId = req.headers['mcp-session-id'] || req.query.sessionId || randomUUID();
+            sessionManager.createSession(sessionId);
+            const body = req.body;
+            if (!body || !body.method) {
+                return res.status(400).json({ error: 'Invalid request' });
             }
-        });
 
-        app.all('/mcp/:path', mcpLimiter, async (req, res) => {
-            try {
-                await transport.handleRequest(req, res, req.body);
-            } catch (error) {
-                log(`Transport error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
+            const { server, transport } = getOrCreateSessionServer(sessionId);
+            transport.resetCleanupTimer();
+
+            await mcpContext.run({ sessionId }, async () => {
+                try {
+                    const response = await transport.handleRequest(body);
+                    if (response) {
+                        const headers = { 'Content-Type': 'application/json' };
+                        if (transport.sessionId) {
+                            headers['mcp-session-id'] = transport.sessionId;
+                        }
+                        res.writeHead(200, headers);
+                        res.end(JSON.stringify(response));
+                    } else {
+                        if (!res.headersSent) {
+                            res.status(202).end();
+                        }
+                    }
+                } catch (error) {
+                    log(`Transport error [${sessionId}]: ${error.message}`);
+                    if (!res.headersSent) {
+                        res.status(500).json({ error: 'Internal server error', message: error.message });
+                    }
                 }
-            }
-        });
+            });
+        }
+
+        app.all('/mcp', mcpLimiter, handleMcpPost);
+        app.all('/mcp/:path', mcpLimiter, handleMcpPost);
+        app.get('/mcp/stream', mcpLimiter, handleMcpPost);
 
         const sseEndpoint = '/sse';
         app.get(sseEndpoint, async (req, res) => {
-            const sseTransport = new SSEServerTransport(sseEndpoint, res);
-            try {
-                await mcpServer.connect(sseTransport);
-                await sseTransport.handleRequest(req, res);
-            } catch (error) {
-                log(`SSE transport error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
-            }
-        });
-        app.post(sseEndpoint, mcpLimiter, async (req, res) => {
-            const sessionId = req.headers['mcp-session-id'];
-            const sseTransport = sessionId ? sseEndpoint + '?sessionId=' + sessionId : sseEndpoint;
-            try {
-                const transport = new SSEServerTransport(sseEndpoint, res);
-                await mcpServer.connect(transport);
-                await transport.handleRequest(req, res);
-            } catch (error) {
-                log(`SSE POST error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
-            }
-        });
+            const sessionId = randomUUID();
+            sessionManager.createSession(sessionId);
+            getOrCreateSessionServer(sessionId);
 
-        app.get('/mcp/sse', async (req, res) => {
-            const sseTransport = new SSEServerTransport('/mcp/sse', res);
-            try {
-                await mcpServer.connect(sseTransport);
-                await sseTransport.handleRequest(req, res);
-            } catch (error) {
-                log(`/mcp/sse transport error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
-            }
-        });
-        app.post('/mcp/sse', mcpLimiter, async (req, res) => {
-            const sseTransport = new SSEServerTransport('/mcp/sse', res);
-            try {
-                await mcpServer.connect(sseTransport);
-                await sseTransport.handleRequest(req, res);
-            } catch (error) {
-                log(`/mcp/sse POST error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
-            }
-        });
+            const sseSession = new SseSession(res, { clientId: sessionId });
+            sseSessionManager.add(sessionId, sseSession);
 
-        app.get('/mcp/stream', async (req, res) => {
-            try {
-                await transport.handleRequest(req, res, req.body);
-            } catch (error) {
-                log(`/mcp/stream error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
-            }
+            sseSession.sendEndpoint(`/message?sessionId=${sessionId}`);
+
+            req.on('close', () => {
+                sseSessionManager.remove(sessionId);
+                removeSessionServer(sessionId);
+            });
         });
 
         app.post('/message', mcpLimiter, async (req, res) => {
-            try {
-                const sessionId = req.headers['mcp-session-id'];
-                const sseTransport = new SSEServerTransport('/message', res);
-                await mcpServer.connect(sseTransport);
-                await sseTransport.handleRequest(req, res);
-            } catch (error) {
-                log(`/message error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
+            const sessionId = req.query.sessionId;
+            if (!sessionId) {
+                return res.status(400).json({ error: 'Missing sessionId' });
+            }
+            const sseSession = sseSessionManager.get(sessionId);
+            if (!sseSession) {
+                return res.status(404).json({ error: 'Session not found' });
+            }
+            sessionManager.createSession(sessionId);
+            const { server, transport } = getOrCreateSessionServer(sessionId);
+            transport.resetCleanupTimer();
+
+            const body = req.body;
+            if (body && body.method) {
+                try {
+                    const response = await transport.handleRequest(body);
+                    if (response) {
+                        sseSession.sendResponse(response);
+                    }
+                    if (!res.headersSent) {
+                        res.status(202).end();
+                    }
+                } catch (error) {
+                    log(`SSE message error [${sessionId}]: ${error.message}`);
+                    if (!res.headersSent) {
+                        res.status(500).json({ error: 'Internal server error' });
+                    }
                 }
+            } else {
+                res.status(400).json({ error: 'Invalid request' });
             }
         });
 
         const httpServer = app.listen(config.port, config.host, async () => {
             await initCadConnection();
-            console.error(`@lisp MCP Server 启动 - http://${config.host}:${config.port} - Streamable HTTP (SDK)`);
+            console.error(`@lisp MCP Server 启动 - http://${config.host}:${config.port} (多会话模式)`);
         });
 
         async function shutdown(signal) {
             console.error(`\n收到 ${signal}，正在优雅关闭...`);
-            await transport.close();
+            sseSessionManager.closeAll();
+            sessionManager.clear();
+            for (const [sid] of sessionServers) {
+                removeSessionServer(sid);
+            }
             await cad.disconnect();
             closeLog();
             httpServer.close(() => process.exit(0));

package/src/cad-worker.js

@@ -244,10 +244,11 @@ process.stdin.on('data', (data) => {
     if (!line.trim()) continue;
     try {
       const msg = JSON.parse(line);
+      const requestId = msg.requestId;
       handleMessage(msg).then(result => {
-        process.stdout.write(JSON.stringify(result) + '\n');
+        process.stdout.write(JSON.stringify({ ...result, requestId }) + '\n');
       }).catch(err => {
-        process.stdout.write(JSON.stringify({ error: err.message }) + '\n');
+        process.stdout.write(JSON.stringify({ error: err.message, requestId }) + '\n');
       });
     } catch (e) {
       process.stdout.write(JSON.stringify({ error: 'invalid message' }) + '\n');

package/src/cad.js

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { randomUUID } from 'crypto';
 import { CAD_PLATFORMS, FILE_EXTENSIONS } from './constants.js';
 import config from './config.js';
 
@@ -15,8 +16,19 @@ let _platform = null;
 let _version = null;
 
 let heartbeatTimer = null;
+const pendingRequests = new Map();
+let stdoutHandlerSetup = false;
+
+const MAX_BUFFER_SIZE = 1024 * 1024;
 
 export function resetWorker() {
+  for (const [id, { reject, timeout }] of pendingRequests) {
+    clearTimeout(timeout);
+    reject(new Error('Worker reset'));
+  }
+  pendingRequests.clear();
+  stdoutHandlerSetup = false;
+
   if (worker) {
     worker.kill();
     worker = null;
@@ -27,6 +39,43 @@ export function resetWorker() {
   }
 }
 
+function setupStdoutHandler(w) {
+  let buffer = '';
+  stdoutHandlerSetup = true;
+
+  w.stdout.on('data', (data) => {
+    try {
+      buffer += data.toString();
+      if (buffer.length > MAX_BUFFER_SIZE) {
+        buffer = buffer.slice(-MAX_BUFFER_SIZE);
+      }
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const result = JSON.parse(line);
+          const rid = result.requestId;
+          if (rid && pendingRequests.has(rid)) {
+            const { resolve, reject, timeout } = pendingRequests.get(rid);
+            clearTimeout(timeout);
+            pendingRequests.delete(rid);
+            if (result.error) {
+              reject(new Error(result.error));
+            } else {
+              resolve(result);
+            }
+          }
+        } catch (parseErr) {
+          console.error('JSON parse error in worker output:', parseErr.message);
+        }
+      }
+    } catch (e) {
+      console.error('Unexpected error in worker stdout handler:', e.message);
+    }
+  });
+}
+
 export function getWorker() {
   if (!worker || !worker.connected) {
     if (worker) worker.kill();
@@ -34,18 +83,27 @@ export function getWorker() {
       stdio: ['pipe', 'pipe', 'pipe']
     });
     worker.connected = true;
-    
+
     worker.stderr.on('data', (d) => console.error('worker stderr:', d.toString()));
     const w = worker;
     w.on('exit', (code) => {
       console.error('worker exited:', code);
       if (w !== worker) return;
       w.connected = false;
+
+      for (const [id, { reject, timeout }] of pendingRequests) {
+        clearTimeout(timeout);
+        reject(new Error(`Worker exited with code ${code}`));
+      }
+      pendingRequests.clear();
+      stdoutHandlerSetup = false;
+
       if (heartbeatTimer) {
         clearInterval(heartbeatTimer);
         heartbeatTimer = null;
       }
     });
+    setupStdoutHandler(w);
     startHeartbeat();
   }
   return worker;
@@ -68,53 +126,26 @@ function startHeartbeat() {
 }
 
 export function sendMessage(msg) {
-  return new Promise((resolve, reject) => {
-    const w = getWorker();
-    let responded = false;
-    let buffer = '';
+  const w = getWorker();
+  const requestId = randomUUID();
 
+  return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {
-      if (!responded) {
-        responded = true;
+      const pending = pendingRequests.get(requestId);
+      if (pending) {
+        pendingRequests.delete(requestId);
         reject(new Error('Timeout waiting for worker'));
       }
     }, MESSAGE_TIMEOUT);
 
-    const handler = (data) => {
-      try {
-        buffer += data.toString();
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const result = JSON.parse(line);
-            if (result.error) {
-              if (!responded) {
-                responded = true;
-                clearTimeout(timeout);
-                w.stdout.off('data', handler);
-                reject(new Error(result.error));
-              }
-            } else {
-              if (!responded) {
-                responded = true;
-                clearTimeout(timeout);
-                w.stdout.off('data', handler);
-                resolve(result);
-              }
-            }
-          } catch (parseErr) {
-            console.error('JSON parse error in worker output:', parseErr.message, 'line:', line.slice(0, 200));
-          }
-        }
-      } catch (e) {
-        console.error('Unexpected error in worker stdout handler:', e.message);
-      }
-    };
-
-    w.stdout.on('data', handler);
-    w.stdin.write(JSON.stringify(msg) + '\n');
+    pendingRequests.set(requestId, { resolve, reject, timeout });
+    try {
+      w.stdin.write(JSON.stringify({ ...msg, requestId }) + '\n');
+    } catch (e) {
+      clearTimeout(timeout);
+      pendingRequests.delete(requestId);
+      reject(new Error(`Failed to write to worker: ${e.message}`));
+    }
   });
 }
 

package/src/handlers/cad-handlers.js

@@ -78,6 +78,18 @@ export async function installAtlisp() {
     return { content: [{ type: 'text', text: '已发送 @lisp 安装代码到 CAD' }] };
 }
 
+export async function listFunctionsInCad() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const result = await cad.sendCommandWithResult('(atoms-family 0)', null);
+        if (result) return { content: [{ type: 'text', text: result }] };
+        return { content: [{ type: 'text', text: 'CAD 函数列表为空' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
 export async function initAtlisp() {
     if (!cad.connected) { await cad.connect(); }
     if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };

package/src/handlers/function-handlers.js

@@ -1,9 +1,10 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { log } from '../logger.js';
+import * as cadHandlers from './cad-handlers.js';
 
 const FUNCTIONS_DIR = process.env.FUNCTIONS_DIR || '';
-const FUNCTIONS_URL = process.env.FUNCTIONS_URL || 'https://s3.atlisp.cn/json/';
+const FUNCTIONS_URL = process.env.FUNCTIONS_URL || 'http://s3.atlisp.cn/json/functions.json';
 
 async function fileExists(filePath) {
     try { await fs.access(filePath); return true; } catch { return false; }
@@ -13,40 +14,25 @@ export async function getFunctionUsage(funcName, packageName) {
     try {
         let results = [];
 
-        const url = packageName
-            ? `${FUNCTIONS_URL}${packageName}.json`
-            : `${FUNCTIONS_URL}all.json`;
-
         try {
-            const response = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0' } });
+            const response = await fetch(FUNCTIONS_URL, { headers: { 'User-Agent': 'atlisp-mcp' } });
             if (response.ok) {
                 const data = await response.json();
-                if (data.functions) {
-                    const func = data.functions.find(f => f.name === funcName);
-                    if (func) results.push(func);
-                }
+                const funcs = data.functions || [];
+                const func = funcs.find(f => f.name === funcName || f.name === `${packageName}:${funcName}`);
+                if (func) results.push(func);
             }
         } catch (e) {
             log(`function-handlers fetch error: ${e.message}`);
         }
 
         if (results.length === 0 && FUNCTIONS_DIR && await fileExists(FUNCTIONS_DIR)) {
-            if (packageName) {
-                const filePath = path.join(FUNCTIONS_DIR, `${packageName}.json`);
-                if (await fileExists(filePath)) {
-                    const raw = await fs.readFile(filePath, 'utf-8');
-                    const data = JSON.parse(raw);
-                    const func = data.functions?.find(f => f.name === funcName);
-                    if (func) results.push(func);
-                }
-            } else {
-                const files = (await fs.readdir(FUNCTIONS_DIR)).filter(f => f.endsWith('.json'));
-                for (const file of files) {
-                    const raw = await fs.readFile(path.join(FUNCTIONS_DIR, file), 'utf-8');
-                    const data = JSON.parse(raw);
-                    const func = data.functions?.find(f => f.name === funcName);
-                    if (func) results.push(func);
-                }
+            const files = (await fs.readdir(FUNCTIONS_DIR)).filter(f => f.endsWith('.json'));
+            for (const file of files) {
+                const raw = await fs.readFile(path.join(FUNCTIONS_DIR, file), 'utf-8');
+                const data = JSON.parse(raw);
+                const func = data.functions?.find(f => f.name === funcName);
+                if (func) results.push(func);
             }
         }
 
@@ -71,18 +57,15 @@ export async function listFunctions(packageName) {
     try {
         let allFuncs = [];
 
-        const url = packageName
-            ? `${FUNCTIONS_URL}${packageName}.json`
-            : `${FUNCTIONS_URL}all.json`;
-
         try {
-            const response = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0' } });
+            const response = await fetch(FUNCTIONS_URL, { headers: { 'User-Agent': 'atlisp-mcp' } });
             if (response.ok) {
                 const data = await response.json();
-                if (data.functions) {
-                    allFuncs = packageName
-                        ? data.functions
-                        : data.functions.map(f => `${f.name}: ${f.description || '-'}`);
+                const funcs = data.functions || [];
+                if (packageName) {
+                    allFuncs = funcs.filter(f => f.name.startsWith(`${packageName}:`));
+                } else {
+                    allFuncs = funcs.map(f => `${f.name}: ${f.description || '-'}`);
                 }
             }
         } catch (e) {
@@ -92,29 +75,32 @@ export async function listFunctions(packageName) {
         if (allFuncs.length === 0 && FUNCTIONS_DIR && await fileExists(FUNCTIONS_DIR)) {
             const files = (await fs.readdir(FUNCTIONS_DIR)).filter(f => f.endsWith('.json'));
             for (const file of files) {
-                const raw = await fs.readFile(path.join(FUNCTIONS_DIR, file), 'utf-8');
-                const data = JSON.parse(raw);
-                if (packageName) {
-                    if (data.package === packageName) {
-                        allFuncs = data.functions || [];
-                    }
-                } else {
-                    for (const f of (data.functions || [])) {
-                        allFuncs.push(`${f.name}: ${f.description || '-'}`);
+                try {
+                    const raw = await fs.readFile(path.join(FUNCTIONS_DIR, file), 'utf-8');
+                    const data = JSON.parse(raw);
+                    const funcs = data.functions || [];
+                    if (packageName) {
+                        allFuncs = funcs.filter(f => f.name.startsWith(`${packageName}:`));
+                    } else {
+                        for (const f of funcs) {
+                            allFuncs.push(`${f.name}: ${f.description || '-'}`);
+                        }
                     }
+                } catch (err) {
+                    log(`read file ${file} error: ${err.message}`);
                 }
             }
         }
 
         if (allFuncs.length === 0) {
-            return { content: [{ type: 'text', text: '函数库为空' }] };
+            return await cadHandlers.listFunctionsInCad();
         }
 
         if (packageName) {
             return { content: [{ type: 'text', text: `${packageName} 包函数 (${allFuncs.length}):\n${allFuncs.map(f => f.name).join('\n')}` }] };
         }
 
-        return { content: [{ type: 'text', text: `函数库共 ${allFuncs.length} 个函数` }] };
+        return { content: [{ type: 'text', text: allFuncs.join('\n') }] };
     } catch (e) {
         return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
     }

package/src/handlers/package-handlers.js

@@ -1,17 +1,57 @@
+const PACKAGES_LIST_URL = process.env.PACKAGES_LIST_URL || 'http://s3.atlisp.cn/packages-list?fmt=json';
 import { cad } from '../cad.js';
 import { MOCK_PACKAGES } from '../constants.js';
+let cachedPackages = null;
+let cachedAt = null;
+const CACHE_TTL = 10 * 60 * 1000;
+
+async function fetchPackages() {
+    const now = Date.now();
+    if (cachedPackages && cachedAt && (now - cachedAt) < CACHE_TTL) {
+        return cachedPackages;
+    }
+    try {
+        const response = await fetch(PACKAGES_LIST_URL, { headers: { 'User-Agent': 'atlisp-mcp' } });
+        if (response.ok) {
+            const data = await response.json();
+            cachedPackages = data;
+            cachedAt = now;
+            return data;
+        }
+    } catch (e) {}
+    return null;
+}
 
 export async function listPackages() {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    const result = await cad.sendCommandWithResult('(@::package-list-in-local)');
+    if (result && result !== 'nil') return { content: [{ type: 'text', text: result }] };
     const packages = MOCK_PACKAGES.map(p => `${p.name} v${p.version} - ${p.description}`);
     return { content: [{ type: 'text', text: `已安装的 @lisp 包:\n${packages.join('\n')}` }] };
 }
 
 export async function searchPackages(query) {
-    const results = MOCK_PACKAGES.filter(p => p.name.includes(query) || p.description.includes(query));
+    const data = await fetchPackages();
+    if (!data) {
+        return { content: [{ type: 'text', text: '无法获取包列表' }], isError: true };
+    }
+    const results = [];
+    const items = Array.isArray(data) ? data : (data.packages || []);
+    if (query) {
+        const q = query.toLowerCase();
+        for (const p of items) {
+            const name = (p.name || '').toLowerCase();
+            const desc = (p.description || '').toLowerCase();
+            if (name.includes(q) || desc.includes(q)) results.push(p);
+        }
+    } else {
+        for (const p of items) results.push(p);
+    }
     if (results.length === 0) {
         return { content: [{ type: 'text', text: `未找到包含 "${query}" 的包` }] };
     }
-    return { content: [{ type: 'text', text: `搜索结果:\n${results.map(p => `${p.name} v${p.version} - ${p.description}`).join('\n')}` }] };
+    return { content: [{ type: 'text', text: `搜索结果 (${results.length}):\n${results.map(p => `${p.name} v${p.version || ''} - ${p.description || ''}`).join('\n')}` }] };
 }
 
 export async function installPackage(packageName) {

package/src/session-manager.js

@@ -0,0 +1,89 @@
+export class Session {
+  constructor(clientId) {
+    this.clientId = clientId;
+    this.subscriptions = new Set();
+    this.createdAt = Date.now();
+    this.connected = false;
+  }
+}
+
+export class SessionManager {
+  #sessions = new Map();
+
+  createSession(clientId) {
+    let session = this.#sessions.get(clientId);
+    if (!session) {
+      session = new Session(clientId);
+      this.#sessions.set(clientId, session);
+    }
+    return session;
+  }
+
+  getSession(clientId) {
+    return this.#sessions.get(clientId) || null;
+  }
+
+  hasSession(clientId) {
+    return this.#sessions.has(clientId);
+  }
+
+  removeSession(clientId) {
+    return this.#sessions.delete(clientId);
+  }
+
+  subscribe(clientId, uri) {
+    const session = this.#sessions.get(clientId);
+    if (session) {
+      session.subscriptions.add(uri);
+      return true;
+    }
+    return false;
+  }
+
+  unsubscribe(clientId, uri) {
+    const session = this.#sessions.get(clientId);
+    if (session) {
+      return session.subscriptions.delete(uri);
+    }
+    return false;
+  }
+
+  getSubscriptions(clientId) {
+    const session = this.#sessions.get(clientId);
+    return session ? Array.from(session.subscriptions) : [];
+  }
+
+  isSubscribed(clientId, uri) {
+    const session = this.#sessions.get(clientId);
+    return session ? session.subscriptions.has(uri) : false;
+  }
+
+  getAllSubscribedUris() {
+    const all = new Set();
+    for (const session of this.#sessions.values()) {
+      for (const uri of session.subscriptions) {
+        all.add(uri);
+      }
+    }
+    return all;
+  }
+
+  list() {
+    return Array.from(this.#sessions.entries()).map(([id, s]) => ({
+      clientId: id,
+      subscriptions: Array.from(s.subscriptions),
+      createdAt: s.createdAt,
+      connected: s.connected
+    }));
+  }
+
+  count() {
+    return this.#sessions.size;
+  }
+
+  clear() {
+    this.#sessions.clear();
+  }
+}
+
+export default SessionManager;

package/src/session-transport.js

@@ -0,0 +1,89 @@
+import { randomUUID } from 'crypto';
+
+const SESSION_TIMEOUT = 30 * 60 * 1000;
+
+export class SessionTransport {
+  constructor(sessionId) {
+    this.sessionId = sessionId || randomUUID();
+    this.onclose = null;
+    this.onerror = null;
+    this.onmessage = null;
+    this._pendingRequest = null;
+    this._started = false;
+    this._closed = false;
+    this._cleanupTimer = null;
+  }
+
+  async start() {
+    if (this._started) {
+      throw new Error('Transport already started');
+    }
+    this._started = true;
+  }
+
+  async send(message) {
+    if (this._closed) return;
+    if (this._pendingRequest) {
+      const { resolve, reject, timeout } = this._pendingRequest;
+      clearTimeout(timeout);
+      this._pendingRequest = null;
+      resolve(message);
+    }
+  }
+
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    if (this._pendingRequest) {
+      const { reject, timeout } = this._pendingRequest;
+      clearTimeout(timeout);
+      this._pendingRequest = null;
+      reject(new Error('Transport closed'));
+    }
+    this._clearCleanupTimer();
+    this.onclose?.();
+  }
+
+  async handleRequest(message, timeoutMs = 60000) {
+    if (this._closed) {
+      throw new Error('Transport closed');
+    }
+
+    if (!message || !message.method) {
+      throw new Error('Invalid message');
+    }
+
+    if (!message.id) {
+      this.onmessage?.(message);
+      return null;
+    }
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        if (this._pendingRequest?.resolve === resolve) {
+          this._pendingRequest = null;
+          reject(new Error('Request timeout'));
+        }
+      }, timeoutMs);
+
+      this._pendingRequest = { resolve, reject, timeout };
+      this.onmessage?.(message);
+    });
+  }
+
+  resetCleanupTimer() {
+    this._clearCleanupTimer();
+    this._cleanupTimer = setTimeout(() => {
+      this.close();
+    }, SESSION_TIMEOUT);
+  }
+
+  _clearCleanupTimer() {
+    if (this._cleanupTimer) {
+      clearTimeout(this._cleanupTimer);
+      this._cleanupTimer = null;
+    }
+  }
+}
+
+export default SessionTransport;

package/src/subscription-manager.js

@@ -1,25 +1,38 @@
-const subscriptions = new Map();
+import { SessionManager } from './session-manager.js';
+
+const sessionManager = new SessionManager();
 let _notifyFn = null;
 
 export function setNotify(fn) {
     _notifyFn = fn;
 }
 
-export function subscribe(uri) {
-    subscriptions.set(uri, Date.now());
+export function subscribe(uri, sessionId) {
+    if (sessionId) {
+        return sessionManager.subscribe(sessionId, uri);
+    }
     return true;
 }
 
-export function unsubscribe(uri) {
-    return subscriptions.delete(uri);
+export function unsubscribe(uri, sessionId) {
+    if (sessionId) {
+        return sessionManager.unsubscribe(sessionId, uri);
+    }
+    return true;
 }
 
-export function list() {
-    return Array.from(subscriptions.keys());
+export function list(sessionId) {
+    if (sessionId) {
+        return sessionManager.getSubscriptions(sessionId);
+    }
+    return Array.from(sessionManager.getAllSubscribedUris());
 }
 
-export function isSubscribed(uri) {
-    return subscriptions.has(uri);
+export function isSubscribed(uri, sessionId) {
+    if (sessionId) {
+        return sessionManager.isSubscribed(sessionId, uri);
+    }
+    return sessionManager.getAllSubscribedUris().has(uri);
 }
 
 export function notify(uri, data) {
@@ -29,9 +42,11 @@ export function notify(uri, data) {
 }
 
 export function clear() {
-    subscriptions.clear();
+    sessionManager.clear();
 }
 
 export function size() {
-    return subscriptions.size;
-}
+    return sessionManager.count();
+}
+
+export { sessionManager };