mcpstore-gateway 1.3.1 → 2.0.0

package/dist/index.d.ts

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 /**
- * MCP Store Gateway v1.3.1
+ * MCP Store Gateway v2.0.0
  *
- * A single MCP server that gives Claude Code access to ALL your installed MCPs
- * from mcpclaudecode.com. Install MCPs on the website, they appear here instantly.
+ * A single MCP server that proxies ALL your installed MCPs from mcpclaudecode.com.
+ * Install MCPs on the website → they appear automatically, no extra restart needed.
  *
- * Features:
- *   - Hosted MCPs: tools proxied through our backend (e.g. AI Brain)
- *   - External MCPs: auto-configured in ~/.mcp.json (e.g. GitHub, Playwright)
+ * Architecture:
+ *   - Hosted MCPs: tools proxied through the backend API (debate, quick_review)
+ *   - External MCPs: spawned as child processes, tools aggregated into this gateway
+ *   - Periodic sync: re-checks every 60s, notifies Claude via tools/list_changed
  *
  * Setup (one command, that's it):
  *   npx mcpstore-gateway --setup YOUR_API_KEY

package/dist/index.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 /**
- * MCP Store Gateway v1.3.1
+ * MCP Store Gateway v2.0.0
  *
- * A single MCP server that gives Claude Code access to ALL your installed MCPs
- * from mcpclaudecode.com. Install MCPs on the website, they appear here instantly.
+ * A single MCP server that proxies ALL your installed MCPs from mcpclaudecode.com.
+ * Install MCPs on the website → they appear automatically, no extra restart needed.
  *
- * Features:
- *   - Hosted MCPs: tools proxied through our backend (e.g. AI Brain)
- *   - External MCPs: auto-configured in ~/.mcp.json (e.g. GitHub, Playwright)
+ * Architecture:
+ *   - Hosted MCPs: tools proxied through the backend API (debate, quick_review)
+ *   - External MCPs: spawned as child processes, tools aggregated into this gateway
+ *   - Periodic sync: re-checks every 60s, notifies Claude via tools/list_changed
  *
  * Setup (one command, that's it):
  *   npx mcpstore-gateway --setup YOUR_API_KEY
@@ -15,18 +16,166 @@
  * Runtime (called automatically by Claude Code):
  *   npx mcpstore-gateway --api-key YOUR_API_KEY
  */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 const GATEWAY_URL = process.env.MCPSTORE_GATEWAY_URL ||
     "https://rshsqjofouqyhzvzezos.supabase.co/functions/v1";
-// Prefix for auto-managed MCP entries in .mcp.json
+// Prefix for auto-managed MCP entries (legacy, cleaned up on start)
 const MANAGED_PREFIX = "mcpstore-";
-async function syncExternalMcps(apiKey) {
+const SYNC_INTERVAL_MS = 60_000; // Re-sync every 60 seconds
+const SPAWN_TIMEOUT_MS = 30_000; // 30s timeout for child MCP connection
+// ---------------------------------------------------------------------------
+// Child MCP Management
+// ---------------------------------------------------------------------------
+const children = new Map();
+/** Resolve ${VAR} templates in env values from process.env */
+function resolveEnv(env) {
+    if (!env)
+        return {};
+    const resolved = {};
+    for (const [key, value] of Object.entries(env)) {
+        resolved[key] = value.replace(/\$\{(\w+)\}/g, (_, varName) => process.env[varName] || "");
+    }
+    return resolved;
+}
+/** Spawn a child MCP process and connect as client */
+async function spawnChild(mcp) {
+    try {
+        let command = mcp.config.command;
+        let args = mcp.config.args || [];
+        // On Windows, wrap npx/node/uvx commands with cmd /c
+        if (os.platform() === "win32" &&
+            ["npx", "node", "uvx"].includes(command)) {
+            args = ["/c", command, ...args];
+            command = "cmd";
+        }
+        const env = {
+            ...Object.fromEntries(Object.entries(process.env).filter((e) => e[1] != null)),
+            ...resolveEnv(mcp.config.env),
+        };
+        const transport = new StdioClientTransport({
+            command,
+            args,
+            env,
+            stderr: "pipe", // Don't leak child stderr into our stdio
+        });
+        const client = new Client({ name: "mcpstore-gateway", version: "2.0.0" }, { capabilities: {} });
+        // Connect with timeout
+        await Promise.race([
+            client.connect(transport),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Connection timeout")), SPAWN_TIMEOUT_MS)),
+        ]);
+        const { tools } = await client.listTools();
+        return {
+            slug: mcp.slug,
+            name: mcp.name,
+            client,
+            transport,
+            tools: tools || [],
+        };
+    }
+    catch (err) {
+        process.stderr.write(`[mcpstore] Failed to spawn ${mcp.slug}: ${err.message}\n`);
+        return null;
+    }
+}
+/** Kill a child MCP process */
+async function killChild(slug) {
+    const child = children.get(slug);
+    if (!child)
+        return;
+    try {
+        await child.client.close();
+    }
+    catch {
+        // Best effort
+    }
+    children.delete(slug);
+}
+/** Kill all child MCP processes */
+async function killAllChildren() {
+    for (const slug of [...children.keys()]) {
+        await killChild(slug);
+    }
+}
+// ---------------------------------------------------------------------------
+// Tool Aggregation
+// ---------------------------------------------------------------------------
+/** Build aggregated tool list from all child MCPs */
+function getProxiedTools() {
+    const tools = [];
+    for (const [slug, child] of children) {
+        for (const tool of child.tools) {
+            tools.push({
+                ...tool,
+                name: `${slug}__${tool.name}`,
+                description: `[${child.name}] ${tool.description || ""}`,
+            });
+        }
+    }
+    return tools;
+}
+/** Find which child owns a prefixed tool name */
+function findToolOwner(prefixedName) {
+    const sepIdx = prefixedName.indexOf("__");
+    if (sepIdx === -1)
+        return null;
+    const slug = prefixedName.slice(0, sepIdx);
+    const toolName = prefixedName.slice(sepIdx + 2);
+    const child = children.get(slug);
+    if (!child)
+        return null;
+    return { child, toolName };
+}
+// ---------------------------------------------------------------------------
+// Hosted Tools (Backend API proxy — debate, quick_review)
+// ---------------------------------------------------------------------------
+let hostedTools = [];
+async function fetchHostedTools(apiKey) {
+    try {
+        const res = await fetch(`${GATEWAY_URL}/gateway-tools`, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        return data.tools || [];
+    }
+    catch {
+        return [];
+    }
+}
+async function callHostedTool(apiKey, toolName, args) {
+    const res = await fetch(`${GATEWAY_URL}/gateway-call`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ tool: toolName, arguments: args }),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(body.error || `Gateway error: ${res.status}`);
+    }
+    const data = (await res.json());
+    const result = data.result ?? data;
+    return typeof result === "string" ? result : JSON.stringify(result, null, 2);
+}
+// ---------------------------------------------------------------------------
+// Sync: fetch installed MCPs and manage child processes
+// ---------------------------------------------------------------------------
+async function fetchInstalledMcps(apiKey) {
     try {
-        // 1. Fetch installed external MCPs from the API
         const res = await fetch(`${GATEWAY_URL}/gateway-sync`, {
             headers: {
                 Authorization: `Bearer ${apiKey}`,
@@ -34,60 +183,73 @@ async function syncExternalMcps(apiKey) {
             },
         });
         if (!res.ok)
-            return; // Silently fail — sync is best-effort
+            return [];
         const data = (await res.json());
-        const installedSlugs = new Set(data.external_mcps.map((m) => m.slug));
-        // 2. Read current ~/.mcp.json
-        const mcpJsonPath = path.join(os.homedir(), ".mcp.json");
-        let config = {};
-        if (fs.existsSync(mcpJsonPath)) {
-            try {
-                config = JSON.parse(fs.readFileSync(mcpJsonPath, "utf-8"));
-            }
-            catch {
-                return; // Don't mess with a broken config
-            }
-        }
-        if (!config.mcpServers) {
-            config.mcpServers = {};
+        return data.external_mcps || [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Sync installed MCPs: spawn new, kill removed, notify if changed */
+async function sync(apiKey, server) {
+    const installed = await fetchInstalledMcps(apiKey);
+    const installedSlugs = new Set(installed.map((m) => m.slug));
+    let changed = false;
+    // Remove uninstalled MCPs
+    for (const slug of [...children.keys()]) {
+        if (!installedSlugs.has(slug)) {
+            await killChild(slug);
+            changed = true;
         }
-        let changed = false;
-        // 3. Add or update external MCPs (prefixed with mcpstore-)
-        //    Always update so credentials from the vault get injected
-        const isWindows = os.platform() === "win32";
-        for (const mcp of data.external_mcps) {
-            const key = `${MANAGED_PREFIX}${mcp.slug}`;
-            // On Windows, wrap npx/node commands with cmd /c so Claude Code can spawn them
-            const mcpConfig = { ...mcp.config };
-            if (isWindows && (mcpConfig.command === "npx" || mcpConfig.command === "node")) {
-                const originalCommand = mcpConfig.command;
-                const originalArgs = mcpConfig.args || [];
-                mcpConfig.command = "cmd";
-                mcpConfig.args = ["/c", originalCommand, ...originalArgs];
-            }
-            const existing = config.mcpServers[key];
-            if (!existing || JSON.stringify(existing) !== JSON.stringify(mcpConfig)) {
-                config.mcpServers[key] = mcpConfig;
+    }
+    // Spawn newly installed MCPs (skip already running)
+    for (const mcp of installed) {
+        if (!children.has(mcp.slug)) {
+            const child = await spawnChild(mcp);
+            if (child) {
+                children.set(mcp.slug, child);
                 changed = true;
             }
         }
-        // 4. Remove uninstalled MCPs (only those with our prefix)
+    }
+    // Notify Claude Code if tool list changed
+    if (changed) {
+        try {
+            await server.sendToolListChanged();
+        }
+        catch {
+            // Best effort — server might not be connected yet
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Legacy cleanup: remove old mcpstore-* entries from .mcp.json
+// (v1 wrote external MCPs to .mcp.json; v2 proxies them instead)
+// ---------------------------------------------------------------------------
+function cleanupLegacyEntries() {
+    try {
+        const mcpJsonPath = path.join(os.homedir(), ".mcp.json");
+        if (!fs.existsSync(mcpJsonPath))
+            return;
+        const raw = fs.readFileSync(mcpJsonPath, "utf-8");
+        const config = JSON.parse(raw);
+        if (!config.mcpServers)
+            return;
+        let changed = false;
         for (const key of Object.keys(config.mcpServers)) {
-            if (key.startsWith(MANAGED_PREFIX)) {
-                const slug = key.slice(MANAGED_PREFIX.length);
-                if (!installedSlugs.has(slug)) {
-                    delete config.mcpServers[key];
-                    changed = true;
-                }
+            // Remove mcpstore-* entries (but keep "mcpstore" — that's the gateway itself)
+            if (key.startsWith(MANAGED_PREFIX) && key !== "mcpstore") {
+                delete config.mcpServers[key];
+                changed = true;
             }
         }
-        // 5. Write back if changed
         if (changed) {
             fs.writeFileSync(mcpJsonPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
         }
     }
     catch {
-        // Sync is best-effort, never block the server from starting
+        // Best effort
     }
 }
 // ---------------------------------------------------------------------------
@@ -133,6 +295,12 @@ async function runSetup(apiKey) {
     if (!config.mcpServers) {
         config.mcpServers = {};
     }
+    // Clean up legacy mcpstore-* entries from v1
+    for (const key of Object.keys(config.mcpServers)) {
+        if (key.startsWith(MANAGED_PREFIX) && key !== "mcpstore") {
+            delete config.mcpServers[key];
+        }
+    }
     // On Windows, wrap npx with cmd /c so Claude Code can spawn the process
     if (os.platform() === "win32") {
         config.mcpServers.mcpstore = {
@@ -161,102 +329,123 @@ async function runSetup(apiKey) {
     console.log("  +--------------------------------------------------+");
     console.log("");
 }
-async function fetchTools(apiKey) {
-    const res = await fetch(`${GATEWAY_URL}/gateway-tools`, {
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "Content-Type": "application/json",
-        },
-    });
-    if (!res.ok) {
-        const body = await res.json().catch(() => ({}));
-        throw new Error(body.error || `Gateway error: ${res.status}`);
-    }
-    const data = (await res.json());
-    return data.tools || [];
-}
-async function callTool(apiKey, toolName, args) {
-    const res = await fetch(`${GATEWAY_URL}/gateway-call`, {
-        method: "POST",
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ tool: toolName, arguments: args }),
-    });
-    if (!res.ok) {
-        const body = await res.json().catch(() => ({}));
-        throw new Error(body.error || `Gateway call error: ${res.status}`);
-    }
-    const data = (await res.json());
-    return data.result ?? data;
-}
+// ---------------------------------------------------------------------------
+// Runtime mode: MCP server with proxy architecture
+// ---------------------------------------------------------------------------
 async function runServer(apiKey) {
-    // Sync external MCPs to ~/.mcp.json before starting
-    await syncExternalMcps(apiKey);
-    const server = new McpServer({
-        name: "MCP Store",
-        version: "1.3.1",
-    });
-    // Register hosted tools (proxied through our backend)
-    try {
-        const tools = await fetchTools(apiKey);
+    // 1. Clean up legacy mcpstore-* entries from .mcp.json (v1 → v2 migration)
+    cleanupLegacyEntries();
+    // 2. Fetch hosted tools (debate, quick_review — proxied through backend)
+    hostedTools = await fetchHostedTools(apiKey);
+    // 3. Create server with listChanged capability
+    const server = new Server({ name: "MCP Store", version: "2.0.0" }, { capabilities: { tools: { listChanged: true } } });
+    // 4. Initial spawn — fetch installed MCPs and start child processes
+    const installed = await fetchInstalledMcps(apiKey);
+    for (const mcp of installed) {
+        const child = await spawnChild(mcp);
+        if (child) {
+            children.set(mcp.slug, child);
+        }
+    }
+    // 5. Handle tools/list
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const tools = [];
+        // Hosted tools (backend API proxy)
+        for (const ht of hostedTools) {
+            tools.push({
+                name: ht.name,
+                description: ht.description,
+                inputSchema: ht.inputSchema,
+            });
+        }
+        // Proxied external tools (from child MCPs)
+        tools.push(...getProxiedTools());
+        // Fallback info tool if nothing installed
         if (tools.length === 0) {
-            server.tool("mcpstore__info", "No MCPs installed yet. Visit https://www.mcpclaudecode.com/browse to install MCPs.", {}, async () => ({
+            tools.push({
+                name: "mcpstore__info",
+                description: "No MCPs installed yet. Visit https://www.mcpclaudecode.com/browse to install MCPs.",
+                inputSchema: { type: "object", properties: {} },
+            });
+        }
+        return { tools };
+    });
+    // 6. Handle tools/call
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args = {} } = request.params;
+        // Info tool
+        if (name === "mcpstore__info") {
+            return {
                 content: [
                     {
                         type: "text",
-                        text: "You have no MCPs installed. Visit https://www.mcpclaudecode.com/browse to browse and install MCPs. They will appear here automatically!",
+                        text: "You have no MCPs installed yet. Visit https://www.mcpclaudecode.com/browse to browse and install MCPs. They will appear here automatically!",
                     },
                 ],
-            }));
+            };
         }
-        else {
-            for (const tool of tools) {
-                const shape = {};
-                const schema = tool.inputSchema;
-                if (schema?.properties) {
-                    for (const [key, value] of Object.entries(schema.properties)) {
-                        shape[key] = value;
-                    }
-                }
-                server.tool(tool.name, tool.description, shape, async (args) => {
-                    try {
-                        const result = await callTool(apiKey, tool.name, args);
-                        const text = typeof result === "string"
-                            ? result
-                            : JSON.stringify(result, null, 2);
-                        return { content: [{ type: "text", text }] };
-                    }
-                    catch (err) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Error: ${err.message}`,
-                                },
-                            ],
-                            isError: true,
-                        };
-                    }
-                });
+        // Check hosted tools first
+        const hosted = hostedTools.find((t) => t.name === name);
+        if (hosted) {
+            try {
+                const text = await callHostedTool(apiKey, name, args);
+                return { content: [{ type: "text", text }] };
+            }
+            catch (err) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: ${err.message}`,
+                        },
+                    ],
+                    isError: true,
+                };
             }
         }
-    }
-    catch (err) {
-        console.error("Failed to fetch tools from MCP Store:", err.message);
-        server.tool("mcpstore__error", "MCP Store connection error", {}, async () => ({
-            content: [
-                {
-                    type: "text",
-                    text: `Failed to connect to MCP Store: ${err.message}\n\nPlease check your API key and try again.`,
-                },
-            ],
-            isError: true,
-        }));
-    }
+        // Route to child MCP
+        const owner = findToolOwner(name);
+        if (!owner) {
+            return {
+                content: [
+                    { type: "text", text: `Unknown tool: ${name}` },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            const result = await owner.child.client.callTool({
+                name: owner.toolName,
+                arguments: args,
+            });
+            return result;
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error calling ${name}: ${err.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // 7. Connect to Claude Code via stdio
     const transport = new StdioServerTransport();
     await server.connect(transport);
+    // 8. Start periodic sync (after connection — can now send notifications)
+    setInterval(() => {
+        sync(apiKey, server).catch(() => { });
+    }, SYNC_INTERVAL_MS);
+    // 9. Cleanup on exit
+    const cleanup = async () => {
+        await killAllChildren();
+        process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
 }
 // ---------------------------------------------------------------------------
 // Entry point

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcpstore-gateway",
-  "version": "1.3.1",
+  "version": "2.0.0",
   "description": "MCP Store Gateway — One MCP server for all your installed MCPs from mcpclaudecode.com",
   "keywords": ["mcp", "claude", "claude-code", "ai", "gateway", "marketplace"],
   "license": "MIT",