Implement Super-MCP Aggregator Gateway and Auto-Parsing Registry

index.js

@@ -2,9 +2,17 @@ import express from "express";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import fs from "fs";
 
 const app = express();
 const PORT = process.env.PORT || 7860;
+const REGISTRY_PATH = "/tmp/mcp_registry.json";
+
+// In-memory active sub-clients map
+const activeClients = new Map(); // serverName -> { client, tools }
 
 const server = new Server(
   {
@@ -18,7 +26,7 @@ const server = new Server(
   }
 );
 
-// Define tools
+// Define local tools
 const calculateTool = {
   name: "calculate",
   description: "Evaluate a mathematical expression in JS safely",
@@ -34,15 +42,86 @@ const calculateTool = {
   }
 };
 
+// ---------------------------------------------------------------------------
+// Registry Loading & Sub-client Lifecycle
+// ---------------------------------------------------------------------------
+
+async function loadAndConnectServers() {
+  let registry = {};
+  if (fs.existsSync(REGISTRY_PATH)) {
+    try {
+      registry = JSON.parse(fs.readFileSync(REGISTRY_PATH, "utf8"));
+    } catch (e) {
+      console.error("Error reading registry:", e);
+    }
+  }
+
+  // Close existing active clients
+  for (const [name, entry] of activeClients.entries()) {
+    try {
+      await entry.client.close();
+    } catch (e) {}
+  }
+  activeClients.clear();
+
+  // Connect to each registered server
+  for (const [name, serverConfig] of Object.entries(registry)) {
+    try {
+      console.log(`[Registry] Connecting to sub-server: ${name}...`);
+      let transport;
+      if (serverConfig.type === "sse") {
+        transport = new SSEClientTransport(new URL(serverConfig.data.url));
+      } else if (serverConfig.type === "stdio") {
+        transport = new StdioClientTransport({
+          command: serverConfig.data.command,
+          args: serverConfig.data.args || [],
+          env: { ...process.env, ...serverConfig.data.env }
+        });
+      } else {
+        continue;
+      }
+
+      const client = new Client(
+        { name: `proxy-${name}`, version: "1.0.0" },
+        { capabilities: {} }
+      );
+
+      await client.connect(transport);
+      const toolsResult = await client.listTools();
+      const tools = toolsResult.tools || [];
+      
+      activeClients.set(name, { client, tools });
+      console.log(`[Registry] Successfully registered '${name}' with ${tools.length} tools.`);
+    } catch (e) {
+      console.error(`[Registry Error] Failed to connect to '${name}':`, e.message);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Server Request Handlers
+// ---------------------------------------------------------------------------
+
 server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [calculateTool]
-  };
+  const list = [calculateTool];
+  for (const [serverName, entry] of activeClients.entries()) {
+    entry.tools.forEach(t => {
+      list.push({
+        name: `${serverName}__${t.name}`,
+        description: `[from ${serverName}] ${t.description}`,
+        inputSchema: t.inputSchema
+      });
+    });
+  }
+  return { tools: list };
 });
 
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  if (request.params.name === "calculate") {
-    const expr = request.params.arguments?.expression;
+  const name = request.params.name;
+  const args = request.params.arguments;
+
+  if (name === "calculate") {
+    const expr = args?.expression;
     try {
       if (/[^0-9\+\-\*\/\(\)\s\.\,Mathsqrtpow]/i.test(expr)) {
         return {
@@ -61,9 +140,70 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       };
     }
   }
+
+  if (name.includes("__")) {
+    const idx = name.indexOf("__");
+    const serverName = name.substring(0, idx);
+    const actualToolName = name.substring(idx + 2);
+    
+    const entry = activeClients.get(serverName);
+    if (!entry) {
+      throw new Error(`MCP sub-server '${serverName}' is not connected or active.`);
+    }
+    
+    const result = await entry.client.callTool({
+      name: actualToolName,
+      arguments: args
+    });
+    return result;
+  }
+
   throw new Error("Tool not found");
 });
 
+// ---------------------------------------------------------------------------
+// Configuration Parser
+// ---------------------------------------------------------------------------
+
+function parseMcpConfig(input) {
+  // 1. Try parsing as JSON
+  try {
+    const json = JSON.parse(input);
+    if (json.mcpServers) {
+      return { type: "claude_desktop", data: json.mcpServers };
+    }
+    if (json.command) {
+      return { type: "stdio", data: { command: json.command, args: json.args || [], env: json.env || {} } };
+    }
+    if (json.url) {
+      return { type: "sse", data: { url: json.url } };
+    }
+  } catch (e) {
+    // Continue to raw string parsing
+  }
+
+  const str = input.trim();
+
+  // 2. Try parsing as SSE URL
+  if (str.startsWith("http://") || str.startsWith("https://")) {
+    return { type: "sse", data: { url: str } };
+  }
+
+  // 3. Try parsing as stdio Command String
+  const parts = str.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
+  if (parts && parts.length > 0) {
+    const command = parts[0].replace(/^["']|["']$/g, "");
+    const args = parts.slice(1).map(arg => arg.replace(/^["']|["']$/g, ""));
+    return { type: "stdio", data: { command, args, env: {} } };
+  }
+
+  throw new Error("Invalid MCP configuration format");
+}
+
+// ---------------------------------------------------------------------------
+// Express Web Routes
+// ---------------------------------------------------------------------------
+
 let transport = null;
 
 app.get("/sse", (req, res) => {
@@ -80,6 +220,45 @@ app.post("/messages", express.json(), async (req, res) => {
   }
 });
 
+app.post("/api/mcp/register", express.json(), async (req, res) => {
+  const { name, config } = req.body;
+  if (!name || !config) {
+    return res.status(400).json({ error: "Missing name or config payload." });
+  }
+
+  try {
+    const parsed = parseMcpConfig(config);
+    let registry = {};
+    if (fs.existsSync(REGISTRY_PATH)) {
+      try {
+        registry = JSON.parse(fs.readFileSync(REGISTRY_PATH, "utf8"));
+      } catch (e) {}
+    }
+    
+    if (parsed.type === "claude_desktop") {
+      for (const [subName, subConfig] of Object.entries(parsed.data)) {
+        registry[subName] = {
+          type: "stdio",
+          data: {
+            command: subConfig.command,
+            args: subConfig.args || [],
+            env: subConfig.env || {}
+          }
+        };
+      }
+    } else {
+      registry[name] = parsed;
+    }
+    
+    fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2), "utf8");
+    await loadAndConnectServers();
+    
+    return res.json({ status: "success", parsed: parsed });
+  } catch (e) {
+    return res.status(500).json({ error: e.message });
+  }
+});
+
 app.post("/api/research", express.json(), async (req, res) => {
   const { query } = req.body;
   console.log(`[Library] Received research request for: '${query}'`);
@@ -137,6 +316,9 @@ app.post("/api/research", express.json(), async (req, res) => {
   return res.json({ status: "success", brief: fallbackBrief });
 });
 
+// Load existing registry on startup
+loadAndConnectServers().catch(console.error);
+
 app.listen(PORT, () => {
   console.log(`SSE MCP Host listening on port ${PORT}`);
 });