@atlisp/mcp 1.0.27 → 1.1.1

package/package.json

@@ -1,10 +1,10 @@
 {
     "name": "@atlisp/mcp",
-    "version": "1.0.27",
+    "version": "1.1.1",
     "description": "MCP Server for @lisp on CAD",
     "type": "module",
     "bin": {
-        "atlisp-mcp": "./src/cli.js"
+        "atlisp-mcp": "./src/atlisp-mcp.js"
     },
     "main": "src/atlisp-mcp.js",
     "exports": {

package/src/atlisp-mcp.js

@@ -1,10 +1,52 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const { version } = require(path.join(__dirname, '..', 'package.json'));
+
+if (process.argv[1]?.endsWith('atlisp-mcp.js')) {
+    const args = process.argv.slice(2);
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--version' || args[i] === '-v') {
+            console.log(`atlisp-mcp v${version}`);
+            process.exit(0);
+        } else if (args[i] === '--help' || args[i] === '-h') {
+            console.log(`
+@lisp MCP Server v${version}
+
+Usage: atlisp-mcp [options]
+
+Options:
+  -v, --version         Show version number
+  --transport <type>   Transport type: http or stdio (default: http)
+  --port <port>        HTTP port (default: 8110)
+  --host <host>        HTTP host (default: 0.0.0.0)
+  --stdio              Shorthand for --transport stdio
+  -h, --help           Show this help message
+
+Examples:
+  atlisp-mcp                       # Start HTTP server on port 8110
+  atlisp-mcp --port 3000           # Start HTTP server on port 3000
+  atlisp-mcp --stdio               # Start in stdio mode for MCP clients
+  atlisp-mcp --transport stdio     # Same as --stdio
+`);
+            process.exit(0);
+        }
+    }
+}
+
 import express from 'express';
 import rawBody from 'raw-body';
 import iconv from 'iconv-lite';
 import rateLimit from 'express-rate-limit';
+import { randomUUID } from 'crypto';
 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 {
     ListToolsRequestSchema,
     CallToolRequestSchema,
@@ -24,8 +66,6 @@ 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 { SseSession, SSE_EVENTS, createSseResponseHandler, parseLastEventId } from './sse-session.js';
-import { SseSessionManager } from './sse-session-manager.js';
 import { createError, toMcpError } from './errors.js';
 import config from './config.js';
 
@@ -41,10 +81,9 @@ const SERVER_INFO = {
     serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
 };
 
-const { port, host, transport, apiKey, enableSse, rateLimitWindow, rateLimitMax } = config;
+const { port, host, transport, apiKey, rateLimitWindow, rateLimitMax } = config;
 
 if (apiKey) log('API Key authentication enabled');
-if (enableSse) log('SSE mode enabled');
 
 const mcpLimiter = rateLimit({
     windowMs: rateLimitWindow,
@@ -54,16 +93,6 @@ const mcpLimiter = rateLimit({
     message: { error: '请求过于频繁，请稍后再试' }
 });
 
-const sseSessionManager = new SseSessionManager();
-
-subMgr.setNotify((uri, data) => {
-    sseSessionManager.broadcast(SSE_EVENTS.MESSAGE, {
-        jsonrpc: '2.0',
-        method: 'notifications/resources/updated',
-        params: { uri, data }
-    });
-});
-
 export { CAD_PLATFORMS, FILE_EXTENSIONS, MOCK_PACKAGES } from './constants.js';
 
 const TOOL_HANDLERS = {
@@ -371,9 +400,15 @@ export async function startServer() {
     if (config.transport === 'stdio') {
         await initCadConnection();
         const mcpServer = createMcpServer();
-const transport = new StdioServerTransport();
+        const transport = new StdioServerTransport();
         await mcpServer.connect(transport);
         console.error(`${SERVER_NAME} 运行在 stdio 模式`);
+
+        subMgr.setNotify((uri, data) => {
+            mcpServer.sendResourceUpdated({ uri }).catch(err => {
+                log(`Failed to send resource update: ${err.message}`);
+            });
+        });
     } else {
         const app = express();
 
@@ -396,7 +431,7 @@ const transport = new StdioServerTransport();
         });
 
         app.use((req, res, next) => {
-            log(`${req.method} ${req.path} - body: ${JSON.stringify(req.body)}`);
+            log(`${req.method} ${req.path}`);
             next();
         });
 
@@ -414,25 +449,6 @@ const transport = new StdioServerTransport();
             res.json({ status: 'ok', cad: cad.connected ? 'connected' : 'disconnected' });
         });
 
-        app.use((req, res, next) => {
-            const path = req.path;
-            if (path.startsWith('/%7B') || path.startsWith('/{"')) {
-                try {
-                    const decoded = decodeURIComponent(path.slice(1));
-                    if (decoded.startsWith('{"path":')) {
-                        const data = JSON.parse(decoded);
-                        const endpoint = data.path;
-                        log(`Client sent SSE endpoint in URL path, extracting: ${endpoint}`);
-                        req.url = endpoint + ((req._parsedUrl && req._parsedUrl.search) || '');
-                        try { req.path = endpoint; } catch (_) { /* Express 5: req.path is read-only, req.url is sufficient */ }
-                    }
-                } catch (e) {
-                    log(`Failed to parse malformed path: ${e.message}`);
-                }
-            }
-            next();
-        });
-
         if (config.enableCors) {
             app.use((req, res, next) => {
                 res.setHeader('Access-Control-Allow-Origin', config.corsOrigin);
@@ -446,224 +462,136 @@ const transport = new StdioServerTransport();
             });
         }
 
-        createMcpServer();
-
-        function setupSseConnection(req, res) {
-            log(`SSE connect: ${req.method} ${req.path} - session: ${req.get('mcp-session-id') || 'new'}`);
-            const sessionId = req.get('mcp-session-id');
-            const lastEventId = parseLastEventId(req);
-            const clientId = sessionId || crypto.randomUUID();
-
-            res.setHeader('mcp-session-id', clientId);
-
-            let session;
-            if (sessionId && sseSessionManager.has(sessionId)) {
-                session = sseSessionManager.get(sessionId);
-            } else {
-                session = new SseSession(res, { clientId, resumeFromId: lastEventId });
-                sseSessionManager.add(clientId, session);
-            }
+        const mcpServer = createMcpServer();
 
-            if (lastEventId && lastEventId > 0) {
-                session.sendEvent(SSE_EVENTS.MESSAGE, { type: 'resume', lastEventId }, lastEventId + 1);
-            }
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+        });
 
-            session.sendPing();
+        await mcpServer.connect(transport);
+        log('MCP Server connected to StreamableHTTPServerTransport');
 
-            res.on('close', () => {
-                log(`SSE close: session ${clientId}`);
-                sseSessionManager.remove(clientId);
+        subMgr.setNotify((uri, data) => {
+            mcpServer.sendResourceUpdated({ uri }).catch(err => {
+                log(`Failed to send resource update: ${err.message}`);
             });
-        }
-
-        if (enableSse) {
-            app.get('/sse', (req, res) => setupSseConnection(req, res));
-            app.get('/mcp/sse', (req, res) => setupSseConnection(req, res));
-
-            app.post('/mcp/message', mcpLimiter, async (req, res) => {
-                const sessionId = req.get('mcp-session-id') || '';
-                const accept = req.get('Accept') || '';
-                const wantsSse = accept.includes('text/event-stream');
-                log(`POST /mcp/message - session: ${sessionId || 'new'} - wantsSSE: ${wantsSse}`);
-
-                let session;
-                if (sessionId && sseSessionManager.has(sessionId)) {
-                    session = sseSessionManager.get(sessionId);
-                } else if (wantsSse) {
-                    const clientId = sessionId || crypto.randomUUID();
-                    res.setHeader('mcp-session-id', clientId);
-                    session = new SseSession(res, { clientId });
-                    sseSessionManager.add(clientId, session);
-                    log(`POST /mcp/message - created new session: ${clientId}`);
-                    res.on('close', () => {
-                        log(`POST SSE close: session ${clientId}`);
-                        sseSessionManager.remove(clientId);
-                    });
-                }
-
-                const body = req.body || {};
-                const { method, params, id } = body;
-
-                if (!id) {
-                    if (session) res.status(204).end();
-                    else res.status(202).end();
-                    return;
-                }
+        });
 
-                if (session) {
-                    try {
-                        await handleMcpRequest(session, method, params, id);
-                    } catch (e) {
-                        log('SSE message error: ' + e.message);
-                        session.sendError(-32603, e.message, id);
-                    }
-                    res.status(204).end();
-                } else {
-                    await dispatchMcpMethod(
-                        (response) => {
-                            res.setHeader('Content-Type', 'application/json');
-                            res.status(200).json(response);
-                        },
-                        method, params, id
-                    );
+        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' });
                 }
-            });
-        }
+            }
+        });
 
-        app.post('/mcp/stream', mcpLimiter, 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(`POST /mcp/stream - session: ${sessionId} - method: ${method} - wantsSSE: ${wantsSse}`);
-
-            if (wantsSse) {
-                if (!enableSse) {
-                    res.status(400).json({ error: 'SSE mode is disabled' });
-                    return;
+        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 clientId = sessionId || crypto.randomUUID();
-                res.setHeader('mcp-session-id', clientId);
-
-                let session;
-                if (sessionId && sseSessionManager.has(sessionId)) {
-                    session = sseSessionManager.get(sessionId);
-                    if (!id) {
-                        res.status(204).end();
-                        return;
-                    }
-                    await handleMcpRequest(session, method, params, id);
-                    res.status(204).end();
-                    return;
+        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' });
                 }
-
-                session = new SseSession(res, { clientId });
-                sseSessionManager.add(clientId, session);
-
-                if (!id) {
-                    return;
+            }
+        });
+        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' });
                 }
-                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();
-
-            await dispatchMcpMethod(
-                (response) => send(response, true),
-                method, params, id
-            );
         });
 
-        app.get('/mcp', (req, res) => {
-            const accept = req.get('Accept') || '';
-            if (accept.includes('text/event-stream')) {
-                if (!enableSse) {
-                    res.status(400).json({ error: 'SSE mode is disabled' });
-                    return;
+        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' });
                 }
-                setupSseConnection(req, res);
-                return;
             }
-            res.status(200).json({
-                name: SERVER_NAME,
-                version: SERVER_VERSION,
-                transport: 'streamable-http',
-                sseEndpoint: '/sse',
-                messageEndpoint: '/mcp/message'
-            });
         });
-
-        app.post('/mcp', mcpLimiter, 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) {
-                if (!enableSse) {
-                    res.status(400).json({ error: 'SSE mode is disabled' });
-                    return;
+        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 clientId = sessionId || crypto.randomUUID();
-                res.setHeader('mcp-session-id', clientId);
-
-                let session;
-                if (sessionId && sseSessionManager.has(sessionId)) {
-                    session = sseSessionManager.get(sessionId);
-                    if (!id) {
-                        res.status(204).end();
-                        return;
-                    }
-                    await handleMcpRequest(session, method, params, id);
-                    res.status(204).end();
-                    return;
+        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' });
                 }
+            }
+        });
 
-                session = new SseSession(res, { clientId });
-                sseSessionManager.add(clientId, session);
-
-                if (!id) {
-                    return;
+        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' });
                 }
-                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();
-
-            await dispatchMcpMethod(
-                (response) => send(response, true),
-                method, params, id
-            );
+        const httpServer = app.listen(config.port, config.host, async () => {
+            await initCadConnection();
+            console.error(`@lisp MCP Server 启动 - http://${config.host}:${config.port} - Streamable HTTP (SDK)`);
         });
 
-	const httpServer = app.listen(config.port, config.host, async () => {
-	    await initCadConnection();
-	    console.error(`@lisp MCP Server 启动 - http://${config.host}:${config.port} - Streamable HTTP`);
-	});
-
-	async function shutdown(signal) {
-	    console.error(`\n收到 ${signal}，正在优雅关闭...`);
-	    sseSessionManager.closeAll();
-	    await cad.disconnect();
-	    closeLog();
-	    httpServer.close(() => process.exit(0));
-	    setTimeout(() => process.exit(1), 5000);
-	}
-	process.on('SIGINT', () => shutdown('SIGINT'));
-	process.on('SIGTERM', () => shutdown('SIGTERM'));
+        async function shutdown(signal) {
+            console.error(`\n收到 ${signal}，正在优雅关闭...`);
+            await transport.close();
+            await cad.disconnect();
+            closeLog();
+            httpServer.close(() => process.exit(0));
+            setTimeout(() => process.exit(1), 5000);
+        }
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
     }
 }
 

package/src/cli.js

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from 'child_process';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { SERVER_VERSION } from './constants.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const serverPath = path.join(__dirname, 'atlisp-mcp.js');
-
-const args = process.argv.slice(2);
-const env = { ...process.env };
-
-for (let i = 0; i < args.length; i++) {
-  if (args[i] === '--version' || args[i] === '-v') {
-    console.log(`atlisp-mcp v${SERVER_VERSION}`);
-    process.exit(0);
-  } else if (args[i] === '--transport' && args[i + 1]) {
-    env.TRANSPORT = args[i + 1];
-    i++;
-  } else if (args[i] === '--port' && args[i + 1]) {
-    env.PORT = args[i + 1];
-    i++;
-  } else if (args[i] === '--host' && args[i + 1]) {
-    env.HOST = args[i + 1];
-    i++;
-  } else if (args[i] === '--stdio') {
-    env.TRANSPORT = 'stdio';
-  } else if (args[i] === '--help' || args[i] === '-h') {
-    console.log(`
-@lisp MCP Server v${SERVER_VERSION}
-
-Usage: atlisp-mcp [options]
-
-Options:
-  -v, --version         Show version number
-  --transport <type>   Transport type: http or stdio (default: http)
-  --port <port>        HTTP port (default: 8110)
-  --host <host>        HTTP host (default: 0.0.0.0)
-  --stdio              Shorthand for --transport stdio
-  -h, --help           Show this help message
-
-Examples:
-  atlisp-mcp                       # Start HTTP server on port 8110
-  atlisp-mcp --port 3000           # Start HTTP server on port 3000
-  atlisp-mcp --stdio               # Start in stdio mode for MCP clients
-  atlisp-mcp --transport stdio     # Same as --stdio
-`);
-    process.exit(0);
-  }
-}
-
-const child = spawn('node', [serverPath], {
-  env,
-  stdio: 'inherit'
-});
-
-child.on('exit', (code) => {
-  process.exit(code);
-});