@natomalabs/natoma-mcp-gateway 1.0.0

package/README.md

@@ -0,0 +1,28 @@
+# Natoma's Server Gateway for all things MCP
+
+This repo hosts the MCP Bridge proxy that enables the communication between an stdio-based Claude Desktop app and HTTP/SSE supported MCP servers. 
+
+## Purpose
+
+This Bridge Proxy service enables interoperability by:
+
+- Creating a unified communication layer between different MCP implementations
+- Translating stdio protocol messages into HTTP/SSE format
+- Converting server responses back into the expected stdio format
+
+## What is MCP?
+
+Reference: https://modelcontextprotocol.io/introduction
+
+## How It Works
+
+The  acts as an intermediary that:
+
+- Listens for incoming stdio messages from AI client hosts. Example: Claude Desktop
+- Maintains persistent SSE connections with Natoma MCP Platform
+- Handles bi-directional protocol conversion
+- Ensures reliable message delivery and error recovery
+
+This allows applications built for stdio-based MCP to work smoothly with the Natoma MCP Platform  without requiring changes to either side.
+
+Required Node.js Version: Node.js 18 or higher is required to run this project.

package/build/gateway.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+import EventSource from "eventsource";
+const NATOMA_MCP_SERVER_URL = "https://api.app.natoma.ai/api/mcp";
+export class MCPGateway {
+    eventSource = null;
+    sessionId = null;
+    isReady = false;
+    messageQueue = [];
+    reconnectAttempts = 0;
+    baseUrl;
+    sseUrl;
+    messageUrl;
+    maxReconnectAttempts;
+    reconnectDelay;
+    apiKey; // Store the API key
+    constructor(config) {
+        const slug = config?.slug;
+        this.baseUrl = NATOMA_MCP_SERVER_URL;
+        this.sseUrl = slug ? `${this.baseUrl}/${slug}` : `${this.baseUrl}`;
+        this.messageUrl = slug
+            ? `${this.baseUrl}/${slug}/message`
+            : `${this.baseUrl}/message`;
+        this.maxReconnectAttempts = config?.maxReconnectAttempts ?? 3;
+        this.reconnectDelay = config?.reconnectDelay ?? 1000;
+        this.apiKey = config?.apiKey;
+    }
+    async connect() {
+        if (this.eventSource) {
+            console.error("Closing existing connection");
+            this.eventSource.close();
+        }
+        return new Promise((resolve, reject) => {
+            // Include API key in headers if it exists
+            const headers = {
+                Accept: "text/event-stream",
+            };
+            // Add Authorization header if API key is provided
+            if (this.apiKey) {
+                headers["Authorization"] = `Bearer ${this.apiKey}`;
+            }
+            this.eventSource = new EventSource(this.sseUrl, { headers });
+            this.eventSource.onopen = () => {
+                console.error("--- SSE backend connected");
+                this.reconnectAttempts = 0;
+                resolve();
+            };
+            this.eventSource.onerror = (error) => {
+                console.error(`--- SSE backend error: ${error?.message}`);
+                this.handleConnectionError(error);
+                reject(error);
+            };
+            this.setupEventListeners();
+        });
+    }
+    setupEventListeners() {
+        if (!this.eventSource)
+            return;
+        this.eventSource.addEventListener("endpoint", (event) => {
+            const match = event.data.match(/sessionId=([^&]+)/);
+            if (match) {
+                this.sessionId = match[1];
+                this.isReady = true;
+                console.error(`Session established: ${this.sessionId}`);
+                this.processQueuedMessages();
+            }
+        });
+        this.eventSource.addEventListener("message", (event) => {
+            try {
+                console.error(`<-- ${event.data}`);
+                console.log(event.data); // Forward to stdout
+            }
+            catch (error) {
+                console.error(`Error handling message: ${error}`);
+            }
+        });
+    }
+    async handleConnectionError(error) {
+        console.error(`Connection error: ${error.message}`);
+        if (this.eventSource?.readyState === EventSource.CLOSED) {
+            console.error("EventSource connection closed");
+            await this.reconnect();
+        }
+    }
+    async reconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error(`Max reconnection attempts (${this.maxReconnectAttempts}) reached, exiting...`);
+            process.exit(1);
+        }
+        this.reconnectAttempts++;
+        this.isReady = false;
+        try {
+            await new Promise((resolve) => setTimeout(resolve, this.reconnectDelay));
+            await this.connect();
+        }
+        catch (error) {
+            console.error(`Reconnection failed: ${error}`);
+        }
+    }
+    async processMessage(input) {
+        if (!this.isReady || !this.sessionId) {
+            this.messageQueue.push(input);
+            return;
+        }
+        const message = input.toString().trim();
+        console.error(`--> ${message}`);
+        try {
+            const url = `${this.messageUrl}?sessionId=${this.sessionId}`;
+            // Define headers with content type
+            const headers = {
+                "Content-Type": "application/json",
+            };
+            // Add Authorization header if API key is provided
+            if (this.apiKey) {
+                headers["Authorization"] = `Bearer ${this.apiKey}`;
+            }
+            const response = await fetch(url, {
+                method: "POST",
+                headers,
+                body: message,
+            });
+            if (!response.ok) {
+                if (response.status === 503) {
+                    await this.reconnect();
+                }
+                else {
+                    console.error(`Error from server: ${response.status} ${response.statusText}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Request error: ${error}`);
+        }
+    }
+    async processQueuedMessages() {
+        while (this.messageQueue.length > 0) {
+            const message = this.messageQueue.shift();
+            if (message) {
+                await this.processMessage(message);
+            }
+        }
+    }
+    cleanup() {
+        if (this.eventSource) {
+            this.eventSource.close();
+        }
+    }
+}
+// Example usage
+async function main() {
+    const gateway = new MCPGateway({
+        apiKey: process.env.NATOMA_MCP_API_KEY,
+        slug: process.env.NATOMA_MCP_SERVER_INSTALLATION_ID,
+    });
+    try {
+        await gateway.connect();
+        process.stdin.on("data", (data) => gateway.processMessage(data));
+        // Handle cleanup
+        const cleanup = () => {
+            console.error("Shutting down...");
+            gateway.cleanup();
+            process.exit(0);
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+    }
+    catch (error) {
+        console.error(`Fatal error:`, error);
+        process.exit(1);
+    }
+}
+main();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@natomalabs/natoma-mcp-gateway",
+  "version": "1.0.0",
+  "description": "Natoma MCP Gateway",
+  "type": "module",
+  "bin": {
+    "gateway": "./build/gateway.js"
+  },
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "inspector": "node build/gateway.js"
+  },
+  "dependencies": {
+     "@modelcontextprotocol/sdk": "^1.0.3",
+      "eventsource": "^2.0.2",
+      "express": "^4.21.1"
+  },
+  "devDependencies": {
+    "@types/eventsource": "^1.1.15",
+    "@types/node": "^20.11.0",
+    "@types/express": "^5.0.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+      "node": ">=18"
+  }
+
+}