@natomalabs/natoma-mcp-gateway 1.0.1 → 1.0.2

package/README.md

@@ -1,28 +1,145 @@
-# Natoma's Server Gateway for all things MCP
+# Natoma MCP Gateway
 
-This repo hosts the MCP Bridge proxy that enables the communication between an stdio-based Claude Desktop app and HTTP/SSE supported MCP servers. 
+A robust, production-ready gateway that bridges stdio-based MCP clients (like Claude Desktop) with HTTP/SSE-based MCP servers on the Natoma platform.
 
-## Purpose
+## Overview
 
-This Bridge Proxy service enables interoperability by:
+The Natoma MCP Gateway acts as a translation layer that enables seamless communication between different MCP (Model Context Protocol) implementations. It supports both standard and enterprise deployment modes, with automatic reconnection, health monitoring, and robust error handling.
 
-- 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
+## Features
+
+- **Dual Gateway Modes**: NMS (standard) and Enterprise gateways for different deployment scenarios
+- **Protocol Translation**: Converts stdio JSON-RPC messages to HTTP/SSE format and vice versa
+
+## Installation
+
+```bash
+npm install @natomalabs/natoma-mcp-gateway
+```
+
+## Usage
+
+### Environment Variables
+
+Required environment variables:
+
+- `NATOMA_MCP_SERVER_INSTALLATION_ID`: Your MCP server installation ID/slug
+- `NATOMA_MCP_API_KEY`: Your Natoma API key for authentication
+
+### Command Line Usage
+
+```bash
+# Standard NMS Gateway mode
+npx @natomalabs/natoma-mcp-gateway
+
+# Enterprise Gateway mode
+npx @natomalabs/natoma-mcp-gateway --enterprise
+```
+
+### Integration with Claude Desktop
+
+Add to your Claude Desktop MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "your-server-name": {
+      "command": "npx",
+      "args": [
+        "@natomalabs/natoma-mcp-gateway"
+      ],
+      "env": {
+        "NATOMA_MCP_SERVER_INSTALLATION_ID": "your-installation-id",
+        "NATOMA_MCP_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+For enterprise deployments, add `--enterprise` to the args array.
+
+## Architecture
+
+### Gateway Modes
+
+#### NMS Gateway (Standard)
+
+- Uses EventSource for Server-Sent Events
+- Optimized for standard MCP deployments
+- Faster reconnection times (1 second)
+- HTTP-based message delivery
+
+#### Enterprise Gateway
+
+- Uses fetch API with enhanced features
+- Support for both JSON and SSE responses
+- Health check monitoring (every 5 minutes)
+- Extended timeouts (60 seconds)
+- Enhanced error recovery
+
+### Protocol Flow
+
+1. **Initialization**: Gateway connects to Natoma MCP Platform
+2. **Session Establishment**: Secure session created with session ID tracking
+3. **Message Processing**: stdio JSON-RPC messages translated to HTTP/SSE
+4. **Response Handling**: Server responses converted back to stdio format
+5. **Error Recovery**: Automatic reconnection on connection failures
+
+## Configuration
+
+The gateway accepts several configuration options through the `MCPConfig` interface:
+
+- `slug`: Server installation ID (required)
+- `apiKey`: Authentication API key (required)
+- `maxReconnectAttempts`: Maximum reconnection attempts (default: 5)
+- `reconnectDelay`: Delay between reconnection attempts (default: 1000ms for NMS, 2000ms for Enterprise)
+- `timeout`: Request timeout (default: 30000ms for NMS, 60000ms for Enterprise)
 
 ## What is MCP?
 
-Reference: https://modelcontextprotocol.io/introduction
+The Model Context Protocol (MCP) is an open standard for connecting AI assistants to external systems and data sources. Learn more at [modelcontextprotocol.io](https://modelcontextprotocol.io/introduction).
+
+## Requirements
+
+- Node.js 18 or higher
+- Valid Natoma API credentials
+- Network access to api.natoma.app
+
+## Development
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd mcp-gateway
+
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Run in development mode
+npm run dev
+
+# Run enterprise mode in development
+npm run dev:enterprise
+```
+
+## Error Handling
+
+The gateway includes comprehensive error handling:
 
-## How It Works
+- **Connection Errors**: Automatic reconnection with exponential backoff
+- **Authentication Errors**: Clear error messages for invalid API keys
+- **Timeout Handling**: Configurable timeouts with proper cleanup
+- **Protocol Errors**: Validation and error reporting for malformed messages
+- **Resource Management**: Proper cleanup of connections and timeouts
 
-The  acts as an intermediary that:
+## License
 
-- 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
+MIT
 
-This allows applications built for stdio-based MCP to work smoothly with the Natoma MCP Platform  without requiring changes to either side.
+## Support
 
-Required Node.js Version: Node.js 18 or higher is required to run this project.
+For issues and support, please contact the Natoma team or file an issue in the repository.

package/build/base.js

@@ -0,0 +1,54 @@
+// base.ts
+export const NATOMA_NMS_SERVER_URL = "https://api.natoma.app/api/mcp";
+export const NATOMA_ENTERPRISE_SERVER_URL = "https://api.natoma.app/api/mcp";
+export const MCP_SESSION_ID_HEADER = "Mcp-Session-Id";
+// Handle EPIPE errors gracefully
+process.stdout.on("error", (err) => {
+    if (err.code === "EPIPE") {
+        process.exit(0);
+    }
+});
+process.stderr.on("error", (err) => {
+    if (err.code === "EPIPE") {
+        process.exit(0);
+    }
+});
+// Base abstract gateway class
+export class BaseMCPGateway {
+    isReady = false;
+    messageQueue = [];
+    reconnectAttempts = 0;
+    baseUrl;
+    maxReconnectAttempts;
+    reconnectDelay;
+    apiKey;
+    constructor(config) {
+        // Set base URL based on gateway type
+        this.baseUrl = config?.isEnterprise
+            ? NATOMA_ENTERPRISE_SERVER_URL
+            : NATOMA_NMS_SERVER_URL;
+        this.maxReconnectAttempts = 3;
+        this.reconnectDelay = 1000;
+        this.apiKey = config?.apiKey;
+        // Validate that API key is provided
+        if (!this.apiKey) {
+            throw new Error("API key is required for MCP Gateway");
+        }
+        // Debug logging
+        console.error(`[BaseMCPGateway] Gateway Type: ${config?.isEnterprise ? "Enterprise" : "NMS"}`);
+        console.error(`[BaseMCPGateway] Base URL set to: ${this.baseUrl}`);
+        console.error(`[BaseMCPGateway] API Key: ${this.apiKey ? "PROVIDED" : "NOT PROVIDED"}`);
+        console.error(`[BaseMCPGateway] Max reconnect attempts: ${this.maxReconnectAttempts}`);
+    }
+    get ready() {
+        return this.isReady;
+    }
+    async processQueuedMessages() {
+        while (this.messageQueue.length > 0) {
+            const message = this.messageQueue.shift();
+            if (message) {
+                await this.processMessage(message);
+            }
+        }
+    }
+}

package/build/cli.js

@@ -0,0 +1,64 @@
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { setupCommand } from './setup.js';
+import { MCPGateway } from './gateway.js';
+import chalk from 'chalk';
+const startCommand = {
+    command: 'start',
+    describe: 'Start the Natoma MCP Gateway',
+    builder: (yargs) => {
+        return yargs
+            .option('url', {
+            type: 'string',
+            describe: 'The Natoma MCP URL to connect to',
+        })
+            .option('apiKey', {
+            type: 'string',
+            describe: 'API key for authentication',
+            demandOption: true,
+        })
+            .option('slug', {
+            type: 'string',
+            describe: 'Installation ID/slug for the connection',
+        });
+    },
+    handler: async (argv) => {
+        try {
+            const { url, apiKey, slug } = argv;
+            console.log(chalk.cyan('🚀 Starting Natoma MCP Gateway...'));
+            if (url) {
+                console.log(chalk.cyan(`   URL: ${url}`));
+            }
+            if (slug) {
+                console.log(chalk.cyan(`   Installation ID: ${slug}`));
+            }
+            const gateway = new MCPGateway({
+                apiKey: apiKey || process.env.NATOMA_MCP_API_KEY,
+                slug: slug || process.env.NATOMA_MCP_SERVER_INSTALLATION_ID,
+            });
+            await gateway.connect();
+            console.log(chalk.green('✅ Connected to Natoma MCP Server'));
+            process.stdin.on("data", (data) => gateway.processMessage(data));
+            // Handle cleanup
+            const cleanup = () => {
+                console.log(chalk.yellow("Shutting down..."));
+                gateway.cleanup();
+                process.exit(0);
+            };
+            process.on("SIGINT", cleanup);
+            process.on("SIGTERM", cleanup);
+        }
+        catch (error) {
+            console.log(chalk.red('\n❌ Error occurred while starting Natoma MCP Gateway:'));
+            console.log(chalk.red(`   ${error.message}`));
+            console.log(chalk.yellow('\nPlease try again or contact support if the issue persists.\n'));
+            process.exit(1);
+        }
+    },
+};
+yargs(hideBin(process.argv))
+    .command(setupCommand)
+    .command(startCommand)
+    .demandCommand(1, 'You need to specify a command.')
+    .help()
+    .argv;

package/build/ent-gateway.js

@@ -0,0 +1,407 @@
+// ent-gateway.ts
+import { BaseMCPGateway, MCP_SESSION_ID_HEADER, } from "./base.js";
+const JSON_RPC_VERSION = "2.0";
+// Enterprise Gateway - Fetch based with enhanced features
+export class EnterpriseGateway extends BaseMCPGateway {
+    sessionHeaders = {};
+    endpointUrl;
+    timeout;
+    sseAbortController = null;
+    constructor(config) {
+        // Set isEnterprise to true for Enterprise Gateway
+        super({ ...config, isEnterprise: true });
+        // Debug the inherited baseUrl
+        console.error(`[EnterpriseGateway] Inherited baseUrl: ${this.baseUrl}`);
+        const slug = config?.slug;
+        this.endpointUrl = slug ? `${this.baseUrl}/${slug}` : `${this.baseUrl}`;
+        this.timeout = config?.timeout ?? 30000;
+        // Debug final endpoint URL
+        console.error(`[EnterpriseGateway] Final endpoint URL: ${this.endpointUrl}`);
+        console.error(`[EnterpriseGateway] Timeout: ${this.timeout}ms`);
+    }
+    // Simplified validation for production - only log errors
+    validateResponse(response, originalRequest) {
+        if (!response || typeof response !== "object") {
+            console.error("❌ Invalid response format");
+            return response;
+        }
+        if (Array.isArray(response)) {
+            response.forEach((elem, idx) => {
+                this.validateSingleResponse(elem, idx);
+            });
+        }
+        else {
+            this.validateSingleResponse(response);
+        }
+        return response;
+    }
+    validateSingleResponse(resp, index) {
+        const prefix = index !== undefined ? `#${index}: ` : "";
+        if (resp.jsonrpc !== JSON_RPC_VERSION) {
+            console.error(`❌ ${prefix}Invalid jsonrpc version`);
+        }
+        const hasResult = resp.hasOwnProperty("result");
+        const hasError = resp.hasOwnProperty("error");
+        if (!hasResult && !hasError) {
+            console.error(`❌ ${prefix}Response missing both 'result' and 'error' fields`);
+        }
+        if (hasError && resp.error) {
+            console.error(`❌ ${prefix}Server error: ${resp.error.message}`);
+        }
+    }
+    async connect() {
+        try {
+            console.error("--- Connecting to MCP server");
+            console.error(`--- Connection URL: ${this.endpointUrl}`);
+            const initializeRequest = {
+                jsonrpc: JSON_RPC_VERSION,
+                method: "initialize",
+                params: {
+                    capabilities: {
+                        tools: {},
+                        prompts: {},
+                        resources: {},
+                        logging: {},
+                    },
+                    clientInfo: {
+                        name: "claude-desktop-gateway",
+                        version: "1.0.0",
+                    },
+                    protocolVersion: "2025-03-26",
+                },
+                id: 1,
+            };
+            const response = await this.makeRequest(initializeRequest);
+            if (response && response.result) {
+                this.isReady = true;
+                this.reconnectAttempts = 0;
+                console.error("--- MCP server connected successfully");
+                await this.processQueuedMessages();
+            }
+            else {
+                throw new Error(`Initialize failed: ${JSON.stringify(response.error)}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`--- Connection failed: ${errorMessage}`);
+            throw error;
+        }
+    }
+    async makeRequest(messageBody) {
+        const isInitialize = messageBody?.method === "initialize";
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: isInitialize
+                ? "application/json"
+                : "application/json, text/event-stream",
+            ...this.sessionHeaders,
+        };
+        if (this.apiKey) {
+            headers["Authorization"] = `Bearer ${this.apiKey}`;
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        let resp;
+        try {
+            resp = await fetch(this.endpointUrl, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(messageBody),
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                throw new Error(`Request timeout after ${this.timeout}ms`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        // Update session headers
+        resp.headers.forEach((value, key) => {
+            if (key.toLowerCase() === MCP_SESSION_ID_HEADER.toLowerCase()) {
+                this.sessionHeaders[MCP_SESSION_ID_HEADER] = value;
+            }
+        });
+        if (!resp.ok) {
+            const text = await resp.text();
+            console.error(`❌ HTTP Error ${resp.status}: ${text}`);
+            throw new Error(`HTTP ${resp.status}: ${text}`);
+        }
+        const contentType = resp.headers.get("content-type") || "";
+        // Handle JSON response
+        if (contentType.includes("application/json")) {
+            const raw = await resp.text();
+            if (!raw || raw.trim() === "") {
+                throw new Error("Empty JSON response");
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch (parseErr) {
+                console.error("❌ Failed to parse JSON response");
+                throw new Error(`Invalid JSON: ${parseErr.message}`);
+            }
+            this.validateResponse(parsed, messageBody);
+            return parsed;
+        }
+        // Handle SSE stream
+        if (contentType.includes("text/event-stream")) {
+            if (this.sseAbortController) {
+                this.sseAbortController.abort();
+            }
+            this.sseAbortController = new AbortController();
+            await this.readSSEStream(resp, messageBody);
+            return null;
+        }
+        // Handle 202 Accepted
+        if (resp.status === 202) {
+            return {};
+        }
+        const txt = await resp.text();
+        console.error(`❌ Unexpected Content-Type ${contentType}`);
+        throw new Error(`Unexpected Content-Type: ${contentType}`);
+    }
+    async readSSEStream(response, originalRequest) {
+        if (!response.body) {
+            console.error("❌ No response body for SSE");
+            return;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let parts = buffer.split(/\r?\n\r?\n/);
+                buffer = parts.pop() || "";
+                for (const chunk of parts) {
+                    const lines = chunk.split(/\r?\n/);
+                    for (const line of lines) {
+                        if (line.startsWith("data:")) {
+                            const payload = line.slice(5).trim();
+                            // Handle session establishment
+                            const sidMatch = payload.match(/sessionId=([^&]+)/);
+                            if (sidMatch) {
+                                this.sessionHeaders[MCP_SESSION_ID_HEADER] = sidMatch[1];
+                                this.isReady = true;
+                                console.error(`Session established: ${sidMatch[1]}`);
+                                await this.processQueuedMessages();
+                                continue;
+                            }
+                            // Handle JSON-RPC messages
+                            try {
+                                const obj = JSON.parse(payload);
+                                this.validateResponse(obj, originalRequest);
+                                console.log(JSON.stringify(obj));
+                            }
+                            catch {
+                                console.log(payload);
+                            }
+                        }
+                    }
+                }
+            }
+            console.error("⚠️ SSE stream closed by server");
+            await this.handleConnectionError(new Error("SSE closed"));
+        }
+        catch (err) {
+            if (err.name !== "AbortError") {
+                console.error("❌ Error reading SSE:", err);
+                await this.handleConnectionError(err);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async handleConnectionError(error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`Connection error: ${errorMessage}`);
+        if (this.sseAbortController) {
+            this.sseAbortController.abort();
+            this.sseAbortController = null;
+        }
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error(`Max reconnect attempts reached. Exiting.`);
+            process.exit(1);
+        }
+        this.reconnectAttempts++;
+        this.isReady = false;
+        this.sessionHeaders = {};
+        console.error(`Reconnecting in ${this.reconnectDelay}ms (attempt ${this.reconnectAttempts})`);
+        await new Promise((r) => setTimeout(r, this.reconnectDelay));
+        await this.connect();
+    }
+    parseMultipleJSON(input) {
+        const messages = [];
+        let braceCount = 0;
+        let inString = false;
+        let escapeNext = false;
+        let startIndex = -1;
+        for (let i = 0; i < input.length; i++) {
+            const char = input[i];
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (char === "\\") {
+                escapeNext = true;
+                continue;
+            }
+            if (char === '"' && !escapeNext) {
+                inString = !inString;
+            }
+            if (!inString) {
+                if (char === "{") {
+                    if (braceCount === 0)
+                        startIndex = i;
+                    braceCount++;
+                }
+                else if (char === "}") {
+                    braceCount--;
+                    if (braceCount === 0 && startIndex >= 0) {
+                        const jsonObj = input.substring(startIndex, i + 1).trim();
+                        if (jsonObj)
+                            messages.push(jsonObj);
+                        startIndex = -1;
+                    }
+                }
+            }
+        }
+        return messages;
+    }
+    async processMessage(input) {
+        if (!this.isReady) {
+            this.messageQueue.push(input);
+            return;
+        }
+        const rawInput = input.toString().trim();
+        try {
+            const fragments = this.parseMultipleJSON(rawInput);
+            if (fragments.length === 0) {
+                console.error("⚠️ No JSON found in input");
+                return;
+            }
+            for (const raw of fragments) {
+                console.error(`--> ${raw}`);
+                const body = JSON.parse(raw);
+                const isNotification = !body.hasOwnProperty("id");
+                if (isNotification) {
+                    await this.makeNotificationRequest(body);
+                    continue;
+                }
+                const responseObj = await this.makeRequest(body);
+                if (responseObj) {
+                    const respStr = JSON.stringify(responseObj);
+                    console.log(respStr);
+                }
+            }
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            console.error(`❌ Request error: ${errMsg}`);
+            if (errMsg.includes("fetch") ||
+                errMsg.includes("timeout") ||
+                errMsg.includes("503") ||
+                errMsg.includes("502")) {
+                await this.handleConnectionError(err);
+            }
+            else {
+                // Send error response if we can determine the request ID
+                let originalId = null;
+                try {
+                    const fragments = this.parseMultipleJSON(rawInput);
+                    if (fragments.length > 0) {
+                        const parsed = JSON.parse(fragments[0]);
+                        if (parsed.hasOwnProperty("id")) {
+                            originalId = parsed.id;
+                        }
+                    }
+                }
+                catch (parseErr) {
+                    console.error(`⚠️ Failed to extract request ID for error response: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+                }
+                if (originalId !== null) {
+                    const errorResponse = {
+                        jsonrpc: JSON_RPC_VERSION,
+                        error: {
+                            code: -32603,
+                            message: `Gateway error: ${errMsg}`,
+                        },
+                        id: originalId,
+                    };
+                    console.log(JSON.stringify(errorResponse));
+                }
+            }
+        }
+    }
+    async makeNotificationRequest(messageBody) {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...this.sessionHeaders,
+        };
+        if (this.apiKey) {
+            headers["Authorization"] = `Bearer ${this.apiKey}`;
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const resp = await fetch(this.endpointUrl, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(messageBody),
+                signal: controller.signal,
+            });
+            resp.headers.forEach((value, key) => {
+                if (key.toLowerCase() === MCP_SESSION_ID_HEADER.toLowerCase()) {
+                    this.sessionHeaders[MCP_SESSION_ID_HEADER] = value;
+                }
+            });
+            if (!resp.ok && resp.status !== 202) {
+                const text = await resp.text();
+                console.error(`❌ Notification error ${resp.status}: ${text}`);
+                throw new Error(`HTTP ${resp.status}: ${text}`);
+            }
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                throw new Error(`Notification timeout after ${this.timeout}ms`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    cleanup() {
+        this.isReady = false;
+        this.sessionHeaders = {};
+        if (this.sseAbortController) {
+            this.sseAbortController.abort();
+            this.sseAbortController = null;
+        }
+    }
+    async healthCheck() {
+        try {
+            const pingRequest = {
+                jsonrpc: JSON_RPC_VERSION,
+                method: "ping",
+                id: "health-check",
+            };
+            const resp = await this.makeRequest(pingRequest);
+            return resp !== null && !resp.hasOwnProperty("error");
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/build/gateway.js

@@ -1,170 +1,66 @@
 #!/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();
-        }
-    }
+import { NMSGateway } from "./nms-gateway.js";
+import { EnterpriseGateway } from "./ent-gateway.js";
+// Parse command line arguments
+function parseArgs() {
+    const args = process.argv.slice(2);
+    return {
+        enterprise: args.includes("--enterprise"),
+    };
 }
-// Example usage
+// Main function
 async function main() {
-    const gateway = new MCPGateway({
+    const { enterprise } = parseArgs();
+    const slug = process.env.NATOMA_MCP_SERVER_INSTALLATION_ID;
+    if (!slug) {
+        console.error("Please set NATOMA_MCP_SERVER_INSTALLATION_ID env var");
+        process.exit(1);
+    }
+    const config = {
+        slug,
         apiKey: process.env.NATOMA_MCP_API_KEY,
-        slug: process.env.NATOMA_MCP_SERVER_INSTALLATION_ID,
-    });
+        maxReconnectAttempts: 5,
+        reconnectDelay: enterprise ? 2000 : 1000,
+        timeout: enterprise ? 60000 : undefined,
+    };
+    // Create appropriate gateway based on flag
+    const gateway = enterprise
+        ? new EnterpriseGateway(config)
+        : new NMSGateway(config);
+    console.error(`--- Starting ${enterprise ? "Enterprise" : "NMS"} Gateway ---`);
     try {
         await gateway.connect();
-        process.stdin.on("data", (data) => gateway.processMessage(data));
-        // Handle cleanup
-        const cleanup = () => {
+        process.stdin.on("data", (data) => {
+            gateway.processMessage(data).catch((err) => {
+                console.error("Error in processMessage:", err);
+            });
+        });
+        const shutdown = () => {
             console.error("Shutting down...");
             gateway.cleanup();
             process.exit(0);
         };
-        process.on("SIGINT", cleanup);
-        process.on("SIGTERM", cleanup);
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        process.on("uncaughtException", (err) => {
+            console.error("Uncaught exception:", err);
+            shutdown();
+        });
+        // Optional health check for enterprise gateway
+        if (enterprise && gateway instanceof EnterpriseGateway) {
+            setInterval(async () => {
+                if (gateway.ready) {
+                    const ok = await gateway.healthCheck();
+                    if (!ok) {
+                        console.error("Health check failed; reconnecting");
+                        await gateway.handleConnectionError(new Error("Health check failed"));
+                    }
+                }
+            }, 5 * 60 * 1000); // Every 5 minutes
+        }
     }
-    catch (error) {
-        console.error(`Fatal error:`, error);
+    catch (err) {
+        console.error("Fatal error:", err);
         process.exit(1);
     }
 }

package/build/nms-gateway.js

@@ -0,0 +1,131 @@
+// nms-gateway.ts
+import EventSource from "eventsource";
+import { BaseMCPGateway } from "./base.js";
+// NMS Gateway (Non-Enterprise) - EventSource based
+export class NMSGateway extends BaseMCPGateway {
+    eventSource = null;
+    sessionId = null;
+    sseUrl;
+    messageUrl;
+    constructor(config) {
+        // Set isEnterprise to false for NMS Gateway
+        super({ ...config, isEnterprise: false });
+        const slug = config?.slug;
+        this.sseUrl = slug ? `${this.baseUrl}/${slug}` : `${this.baseUrl}`;
+        this.messageUrl = slug
+            ? `${this.baseUrl}/${slug}/message`
+            : `${this.baseUrl}/message`;
+        // Debug the URLs
+        console.error(`[NMSGateway] Base URL: ${this.baseUrl}`);
+        console.error(`[NMSGateway] SSE URL: ${this.sseUrl}`);
+        console.error(`[NMSGateway] Message URL: ${this.messageUrl}`);
+    }
+    async connect() {
+        if (this.eventSource) {
+            console.error("Closing existing connection");
+            this.eventSource.close();
+        }
+        return new Promise((resolve, reject) => {
+            const headers = {
+                Accept: "text/event-stream",
+            };
+            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);
+            }
+            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}`;
+            const headers = {
+                "Content-Type": "application/json",
+            };
+            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}`);
+        }
+    }
+    cleanup() {
+        if (this.eventSource) {
+            this.eventSource.close();
+        }
+    }
+}

package/build/setup.js

@@ -0,0 +1,186 @@
+// setup.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import chalk from "chalk";
+export const setupCommand = {
+    command: "setup <url>",
+    describe: "Setup command for Natoma MCP Gateway integration",
+    builder: (yargs) => {
+        return yargs
+            .positional("url", {
+            type: "string",
+            describe: "The Natoma MCP URL to use",
+            demandOption: true,
+        })
+            .option("client", {
+            type: "string",
+            describe: "Client to use (claude, windsurf, cursor)",
+            default: "claude",
+            choices: ["claude", "windsurf", "cursor"],
+        })
+            .option("apiKey", {
+            type: "string",
+            describe: "API key for authentication",
+            demandOption: true,
+        });
+    },
+    handler: async (argv) => {
+        const { url, client, apiKey } = argv;
+        try {
+            console.log(chalk.cyan("📝 Configuration Details:"));
+            console.log(`   URL: ${chalk.green(url)}`);
+            console.log(`   Client: ${chalk.green(client)}`);
+            if (apiKey) {
+                console.log(`   API Key: ${chalk.green("****" + apiKey.slice(-4))}`);
+            }
+            console.log("");
+            console.log(chalk.cyan("💾 Saving configurations..."));
+            saveMcpConfig(url, client, apiKey);
+            console.log(chalk.cyan(`\n🚀 All done! Please restart ${client} for changes to take effect\n`));
+        }
+        catch (error) {
+            console.log(chalk.red("\n❌ Error occurred while setting up Natoma MCP:"));
+            console.log(chalk.red(`   ${error.message}`));
+            console.log(chalk.yellow("\nPlease try again or contact support if the issue persists.\n"));
+        }
+    },
+};
+function saveMcpConfig(url, clientType, apiKey) {
+    // Create config object for the gateway
+    const config = {
+        command: "npx",
+        args: ["@natomalabs/natoma-mcp-gateway@latest", "start", "--url", url],
+        env: {
+            npm_config_yes: "true",
+        },
+    };
+    // If API key is provided, add it to the environment variables
+    if (apiKey) {
+        config.env["NATOMA_MCP_API_KEY"] = apiKey;
+        // Also add it to the args so it's passed to the start command
+        config.args.push("--apiKey", apiKey);
+    }
+    // Extract installation ID from URL for Cursor
+    const urlParts = url.split("/");
+    const installationId = urlParts[urlParts.length - 1];
+    const sseConfig = {
+        url: url,
+        apiKey: apiKey,
+        slug: installationId,
+    };
+    const homeDir = os.homedir();
+    // Define platform-specific paths
+    const platformPaths = {
+        win32: {
+            baseDir: process.env.APPDATA || path.join(homeDir, "AppData", "Roaming"),
+            vscodePath: path.join("Code", "User", "globalStorage"),
+        },
+        darwin: {
+            baseDir: path.join(homeDir, "Library", "Application Support"),
+            vscodePath: path.join("Code", "User", "globalStorage"),
+        },
+        linux: {
+            baseDir: process.env.XDG_CONFIG_HOME || path.join(homeDir, ".config"),
+            vscodePath: path.join("Code/User/globalStorage"),
+        },
+    };
+    const platform = process.platform;
+    // Check if platform is supported
+    if (!platformPaths[platform]) {
+        console.log(chalk.yellow(`\n⚠️ Platform ${platform} is not supported.`));
+        return;
+    }
+    const { baseDir } = platformPaths[platform];
+    // Define client-specific paths
+    const clientPaths = {
+        claude: {
+            configDir: path.join(baseDir, "Claude"),
+            configPath: path.join(baseDir, "Claude", "claude_desktop_config.json"),
+        },
+        windsurf: {
+            configDir: path.join(homeDir, ".codeium", "windsurf"),
+            configPath: path.join(homeDir, ".codeium", "windsurf", "mcp_config.json"),
+        },
+        cursor: {
+            configDir: path.join(homeDir, ".cursor"),
+            configPath: path.join(homeDir, ".cursor", "mcp.json"),
+        },
+    };
+    if (!clientPaths[clientType]) {
+        console.log(chalk.yellow(`\n⚠️ Client ${clientType} is not supported.`));
+        return;
+    }
+    const { configDir, configPath } = clientPaths[clientType];
+    // Create config directory if it doesn't exist
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    // Handle client-specific configuration format
+    if (clientType === "claude") {
+        let claudeConfig = { mcpServers: {} };
+        if (fs.existsSync(configPath)) {
+            try {
+                claudeConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            }
+            catch (error) {
+                console.log(chalk.yellow("⚠️  Creating new config file"));
+            }
+        }
+        // Ensure mcpServers exists
+        if (!claudeConfig.mcpServers)
+            claudeConfig.mcpServers = {};
+        // Update only the mcpServers entry
+        claudeConfig.mcpServers[url] = config;
+        fs.writeFileSync(configPath, JSON.stringify(claudeConfig, null, 2));
+        console.log(chalk.green(`✅ Configuration saved to: ${configPath}`));
+    }
+    else if (clientType === "windsurf") {
+        let windsurfConfig = { mcpServers: {} };
+        if (fs.existsSync(configPath)) {
+            try {
+                windsurfConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            }
+            catch (error) {
+                console.log(chalk.yellow("⚠️  Creating new config file"));
+            }
+        }
+        // Ensure mcpServers exists
+        if (!windsurfConfig.mcpServers)
+            windsurfConfig.mcpServers = {};
+        // Now TypeScript knows mcpServers exists
+        windsurfConfig.mcpServers[url] = config;
+        fs.writeFileSync(configPath, JSON.stringify(windsurfConfig, null, 2));
+        console.log(chalk.green(`✅ Configuration saved to: ${configPath}`));
+    }
+    else if (clientType === "cursor") {
+        let cursorConfig = { mcpServers: {} };
+        if (fs.existsSync(configPath)) {
+            try {
+                cursorConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            }
+            catch (error) {
+                console.log(chalk.yellow("⚠️  Creating new config file"));
+            }
+        }
+        // Ensure mcpServers exists
+        if (!cursorConfig.mcpServers)
+            cursorConfig.mcpServers = {};
+        // Remove existing config if it exists
+        if (cursorConfig.mcpServers[url]) {
+            delete cursorConfig.mcpServers[url];
+        }
+        try {
+            // Create a unique key for Cursor's configuration
+            const newKey = `natoma_${installationId}`;
+            cursorConfig.mcpServers[newKey] = sseConfig;
+            fs.writeFileSync(configPath, JSON.stringify(cursorConfig, null, 2));
+            console.log(chalk.green(`✅ Configuration saved to: ${configPath}`));
+        }
+        catch (error) {
+            console.log(chalk.red("❌ Error occurred while setting up MCP:"));
+            console.log(chalk.red(`   ${error.message}`));
+            console.log(chalk.yellow("\nPlease try again or contact support if the issue persists.\n"));
+        }
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@natomalabs/natoma-mcp-gateway",
-  "version": "1.0.1",
-  "description": "Natoma MCP Gateway",
+  "version": "1.0.2",
+  "description": "Natoma MCP Gateway with NMS and Enterprise modes",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -13,21 +13,24 @@
   "scripts": {
     "build": "tsc",
     "prepare": "npm run build",
-    "inspector": "node build/gateway.js"
+    "inspector": "node build/gateway.js",
+    "inspector:enterprise": "node build/gateway.js --enterprise",
+    "dev": "tsx watch src/gateway.ts",
+    "dev:enterprise": "tsx watch src/gateway.ts --enterprise"
   },
   "dependencies": {
-     "@modelcontextprotocol/sdk": "^1.0.3",
-      "eventsource": "^2.0.2",
-      "express": "^4.21.1"
+    "@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",
+    "@types/node": "^20.11.0",
+    "tsx": "^4.0.0",
     "typescript": "^5.3.3"
   },
   "engines": {
-      "node": ">=18"
+    "node": ">=18"
   }
-
-}
+}