@atlisp/mcp 1.1.0 → 1.1.1

package/package.json

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

package/src/atlisp-mcp.js

@@ -1,18 +1,20 @@
-import { fileURLToPath } from 'url';
 import path from 'path';
-import { SERVER_VERSION } from './constants.js';
+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${SERVER_VERSION}`);
+            console.log(`atlisp-mcp v${version}`);
             process.exit(0);
         } else if (args[i] === '--help' || args[i] === '-h') {
             console.log(`
-@lisp MCP Server v${SERVER_VERSION}
+@lisp MCP Server v${version}
 
 Usage: atlisp-mcp [options]
 
@@ -44,6 +46,7 @@ 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,
@@ -496,6 +499,84 @@ export async function startServer() {
             }
         });
 
+        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' });
+                }
+            }
+        });
+
+        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' });
+                }
+            }
+        });
+
+        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' });
+                }
+            }
+        });
+
+        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 httpServer = app.listen(config.port, config.host, async () => {
             await initCadConnection();
             console.error(`@lisp MCP Server 启动 - http://${config.host}:${config.port} - Streamable HTTP (SDK)`);