@cnbcool/mcp-server 0.4.4 → 0.5.0

package/dist/helpers/createTransport.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transports = void 0;
+exports.createStreamableTransport = createStreamableTransport;
+exports.createStatelessStreamableTransport = createStatelessStreamableTransport;
+const node_crypto_1 = require("node:crypto");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const createMcpServer_1 = require("./createMcpServer");
+// Store transports for each session type
+exports.transports = {
+    streamable: {},
+    sse: {}
+};
+async function createStreamableTransport(req) {
+    const sessionId = req.headers['mcp-session-id'];
+    // Reuse existing transport
+    if (sessionId && exports.transports.streamable[sessionId]) {
+        const transport = exports.transports.streamable[sessionId];
+        if (!(transport instanceof streamableHttp_js_1.StreamableHTTPServerTransport)) {
+            throw {
+                status: 400,
+                message: 'Session exists but uses a different transport protocol'
+            };
+        }
+        return transport;
+    }
+    // New initialization request
+    if (!sessionId && (0, types_js_1.isInitializeRequest)(req.body)) {
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            sessionIdGenerator: () => (0, node_crypto_1.randomUUID)(),
+            onsessioninitialized: (sessionId) => {
+                exports.transports.streamable[sessionId] = transport;
+            }
+        });
+        // Clean up transport when closed
+        transport.onclose = () => {
+            if (transport.sessionId) {
+                delete exports.transports.streamable[transport.sessionId];
+            }
+        };
+        const mcpServer = (0, createMcpServer_1.createMcpServer)(req);
+        await mcpServer.connect(transport);
+        return transport;
+    }
+    throw {
+        status: 400,
+        message: 'No valid session ID provided'
+    };
+}
+async function createStatelessStreamableTransport(req, res) {
+    try {
+        const mcpServer = (0, createMcpServer_1.createMcpServer)(req);
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined
+        });
+        res.on('close', () => {
+            console.log('Request closed');
+            void transport.close();
+            void mcpServer.close();
+        });
+        await mcpServer.connect(transport);
+        return transport;
+    }
+    catch (error) {
+        console.error('Error handling MCP request:', error);
+        if (!res.headersSent) {
+            throw new Error('Internal Server Error');
+        }
+        throw error;
+    }
+}

package/dist/helpers/formatRepoUrl.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRepoPath = getRepoPath;
 function getRepoPath(url) {
+    var _a;
     let repoPath = '';
     if (!url)
         return repoPath;
@@ -10,9 +11,9 @@ function getRepoPath(url) {
         // Remove leading /
         repoPath = urlObj.pathname.substring(1);
     }
-    catch (_a) {
-        // ssh format address
-        repoPath = url.split(':')[1];
+    catch (_b) {
+        // ssh format address or malformed url
+        repoPath = (_a = url.split(':')[1]) !== null && _a !== void 0 ? _a : '';
     }
     // Remove tailing .git
     repoPath = repoPath.replace(/\.git$/, '');

package/dist/helpers/sendResponse.js

@@ -1,12 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stopWithWrongTransport = stopWithWrongTransport;
-function stopWithWrongTransport(res) {
+exports.stopWithError = stopWithError;
+exports.stopWithBadRequest = stopWithBadRequest;
+exports.stopWithMethodNotAllowed = stopWithMethodNotAllowed;
+exports.stopWithServerError = stopWithServerError;
+function stopWithError(res, status, message) {
+    if (status === 400) {
+        stopWithBadRequest(res, message);
+        return;
+    }
+    if (status === 405) {
+        stopWithMethodNotAllowed(res, message);
+        return;
+    }
+    stopWithServerError(res, message);
+}
+function stopWithBadRequest(res, message) {
     res.status(400).json({
         jsonrpc: '2.0',
         error: {
             code: -32000,
-            message: 'Bad Request: Session exists but uses a different transport protocol'
+            message
+        },
+        id: null
+    });
+}
+function stopWithMethodNotAllowed(res, message) {
+    res.writeHead(405).end(JSON.stringify({
+        jsonrpc: '2.0',
+        error: {
+            code: -32000,
+            message
+        },
+        id: null
+    }));
+}
+function stopWithServerError(res, message) {
+    res.status(500).json({
+        jsonrpc: '2.0',
+        error: {
+            code: -32603,
+            message
         },
         id: null
     });

package/dist/streamable.js

@@ -6,93 +6,69 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = __importDefault(require("express"));
-const node_crypto_1 = require("node:crypto");
-const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const dotenv_1 = __importDefault(require("dotenv"));
 const createMcpServer_js_1 = require("./helpers/createMcpServer.js");
 const sendResponse_js_1 = require("./helpers/sendResponse.js");
+const createTransport_js_1 = require("./helpers/createTransport.js");
 dotenv_1.default.config();
 const DEFAULT_APP_PORT = 3000;
-// Store transports for each session type
-const transports = {
-    streamable: {},
-    sse: {}
-};
 const app = (0, express_1.default)();
 app.use(express_1.default.json());
 app.post('/mcp', async (req, res) => {
-    const sessionId = req.headers['mcp-session-id'];
     let transport;
-    // Reuse existing transport
-    if (sessionId && transports.streamable[sessionId]) {
-        transport = transports.streamable[sessionId];
-        if (!(transport instanceof streamableHttp_js_1.StreamableHTTPServerTransport)) {
-            (0, sendResponse_js_1.stopWithWrongTransport)(res);
+    try {
+        transport = process.env.MODE_STATELESS
+            ? await (0, createTransport_js_1.createStatelessStreamableTransport)(req, res)
+            : await (0, createTransport_js_1.createStreamableTransport)(req);
+    }
+    catch (err) {
+        if (typeof err === 'object' && err !== null && 'status' in err && 'message' in err) {
+            const { status, message } = err;
+            (0, sendResponse_js_1.stopWithError)(res, status, message);
             return;
         }
-        await transport.handleRequest(req, res, req.body);
-        return;
-    }
-    // New initialization request
-    if (!sessionId && (0, types_js_1.isInitializeRequest)(req.body)) {
-        transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
-            sessionIdGenerator: () => (0, node_crypto_1.randomUUID)(),
-            onsessioninitialized: (sessionId) => {
-                transports.streamable[sessionId] = transport;
-            }
-        });
-        // Clean up transport when closed
-        transport.onclose = () => {
-            if (transport.sessionId) {
-                delete transports.streamable[transport.sessionId];
-            }
-        };
-        const mcpServer = (0, createMcpServer_js_1.createMcpServer)(req);
-        await mcpServer.connect(transport);
-        await transport.handleRequest(req, res, req.body);
+        const message = err instanceof Error ? err.message : String(err);
+        (0, sendResponse_js_1.stopWithServerError)(res, message !== null && message !== void 0 ? message : 'Unknown error');
         return;
     }
-    // Invalid request
-    res.status(400).json({
-        jsonrpc: '2.0',
-        error: {
-            code: -32000,
-            message: 'Bad Request: No valid session ID provided'
-        },
-        id: null
-    });
+    await transport.handleRequest(req, res, req.body);
 });
 const handleSessionRequest = async (req, res) => {
+    if (process.env.MODE_STATELESS) {
+        (0, sendResponse_js_1.stopWithMethodNotAllowed)(res, 'Method not allowed');
+        return;
+    }
     const sessionId = req.headers['mcp-session-id'];
-    if (!sessionId || !transports.streamable[sessionId]) {
+    if (!sessionId || !createTransport_js_1.transports.streamable[sessionId]) {
         res.status(400).send('Invalid or missing session ID');
         return;
     }
-    const transport = transports.streamable[sessionId];
+    const transport = createTransport_js_1.transports.streamable[sessionId];
     await transport.handleRequest(req, res, req.body);
 };
+// SSE notifications not supported in stateless mode
 app.get('/mcp', handleSessionRequest);
+// Session termination not needed in stateless mode
 app.delete('/mcp', handleSessionRequest);
 app.get('/sse', async (req, res) => {
     const transport = new sse_js_1.SSEServerTransport('/messages', res);
-    transports.sse[transport.sessionId] = transport;
+    createTransport_js_1.transports.sse[transport.sessionId] = transport;
     res.on('close', () => {
-        delete transports.sse[transport.sessionId];
+        delete createTransport_js_1.transports.sse[transport.sessionId];
     });
     const mcpServer = (0, createMcpServer_js_1.createMcpServer)(req);
     await mcpServer.connect(transport);
 });
 app.post('/messages', async (req, res) => {
     const sessionId = req.query.sessionId;
-    const transport = transports.sse[sessionId];
+    const transport = createTransport_js_1.transports.sse[sessionId];
     if (!transport) {
         res.status(400).send('No transport found for sessionId');
         return;
     }
     if (!(transport instanceof sse_js_1.SSEServerTransport)) {
-        (0, sendResponse_js_1.stopWithWrongTransport)(res);
+        (0, sendResponse_js_1.stopWithBadRequest)(res, 'Bad Request: Session exists but uses a different transport protocol');
         return;
     }
     await transport.handlePostMessage(req, res, req.body);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cnbcool/mcp-server",
   "description": "CNB MCP Server. A comprehensive MCP server that provides seamless integration to the CNB's API(https://cnb.cool), offering a wide range of tools for repository management, pipelines operations and collaboration features",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "main": "./dist/stdio.js",
   "bin": {
     "cnb-mcp-stdio": "dist/stdio.js",