@natomalabs/natoma-mcp-gateway 1.0.3 → 1.0.5

package/build/nms-gateway.js

@@ -1,131 +0,0 @@
-// 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

@@ -1,186 +0,0 @@
-// 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"));
-        }
-    }
-}