@toolsdk.ai/registry 1.0.168 → 1.0.169

package/dist/api/index.js

@@ -1,9 +1,11 @@
 import { readFileSync } from "node:fs";
+import { createServer } from "node:http";
 import { join } from "node:path";
-import { serve } from "@hono/node-server";
+import { getRequestListener } from "@hono/node-server";
 import { swaggerUI } from "@hono/swagger-ui";
 import { OpenAPIHono } from "@hono/zod-openapi";
 import { configRoutes } from "../domains/config/config-route";
+import { createMcpGatewayHandler } from "../domains/mcp-gateway/mcp-gateway";
 import { oauthDemoRoutes, oauthRoutes } from "../domains/oauth/oauth-route";
 import { repository } from "../domains/package/package-handler";
 import { packageRoutes } from "../domains/package/package-route";
@@ -76,9 +78,44 @@ app.onError((err, c) => {
     }, 500);
 });
 const port = getServerPort();
-serve({
-    fetch: app.fetch,
-    port,
+// MCP Gateway handler — intercepts /mcp/:packageName before Hono
+const mcpGatewayHandler = createMcpGatewayHandler(repository);
+const MCP_PATH_PREFIX = "/mcp/";
+// Create a raw Node.js HTTP server so we can route /mcp/* to the
+// Streamable HTTP transport (which needs raw IncomingMessage/ServerResponse)
+// and everything else to Hono.
+const honoListener = getRequestListener(app.fetch);
+const server = createServer(async (req, res) => {
+    var _a;
+    const url = (_a = req.url) !== null && _a !== void 0 ? _a : "";
+    if (url.startsWith(MCP_PATH_PREFIX)) {
+        // Extract package name: /mcp/@scope/name or /mcp/name
+        // Handle scoped packages: /mcp/@scope/name → @scope/name
+        const pathAfterPrefix = url.slice(MCP_PATH_PREFIX.length);
+        // Remove query string if any
+        const packageName = decodeURIComponent(pathAfterPrefix.split("?")[0]);
+        if (!packageName) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Missing package name in URL" }));
+            return;
+        }
+        try {
+            await mcpGatewayHandler(req, res, packageName);
+        }
+        catch (error) {
+            console.error("[MCP Gateway] Unhandled error:", error);
+            if (!res.headersSent) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Internal server error" }));
+            }
+        }
+        return;
+    }
+    // All other routes → Hono
+    honoListener(req, res);
+});
+server.listen(port, () => {
+    console.log(`🚀 Server is running on http://localhost:${port}`);
+    console.log(`🔌 MCP Gateway available at http://localhost:${port}/mcp/<packageName>`);
 });
-console.log(`🚀 Server is running on http://localhost:${port}`);
 export default app;

package/dist/domains/mcp-gateway/mcp-gateway.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { PackageRepository } from "../package/package-repository";
+/**
+ * Main request handler for the MCP Gateway.
+ */
+export declare function createMcpGatewayHandler(repository: PackageRepository): (req: IncomingMessage, res: ServerResponse, packageName: string) => Promise<void>;

package/dist/domains/mcp-gateway/mcp-gateway.js

@@ -0,0 +1,184 @@
+import { randomUUID } from "node:crypto";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { getMcpClient } from "../../shared/utils/mcp-client-util";
+/**
+ * Extracts environment variables from request headers.
+ * Headers like `x-mcp-env-TAVILY_API_KEY: xxx` → { TAVILY_API_KEY: "xxx" }
+ */
+function extractEnvFromHeaders(req) {
+    const envs = {};
+    const prefix = "x-mcp-env-";
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (key.toLowerCase().startsWith(prefix) && typeof value === "string") {
+            // Node.js lowercases all header names, so restore the env key to UPPER_CASE
+            const envKey = key.slice(prefix.length).toUpperCase();
+            envs[envKey] = value;
+        }
+    }
+    return envs;
+}
+const sessions = new Map();
+const SESSION_TTL_MS = 30 * 60 * 1000;
+setInterval(() => {
+    const now = Date.now();
+    for (const [id, session] of sessions) {
+        if (now - session.createdAt > SESSION_TTL_MS) {
+            session.server.close().catch(() => { });
+            sessions.delete(id);
+        }
+    }
+}, 5 * 60 * 1000);
+/**
+ * Creates a low-level MCP Server that proxies tools from the target package.
+ *
+ * The `sessionRef` object is shared with the session store so that
+ * `envs` can be updated on every incoming HTTP request. The tools/call
+ * handler always reads `sessionRef.envs` at call time (not at init time).
+ */
+async function createProxyServer(packageName, config, sessionRef) {
+    var _a, _b;
+    // Provide mock envs for listing tools (some servers validate env on startup)
+    const mockEnvs = Object.assign({}, sessionRef.envs);
+    if (config.env) {
+        for (const key of Object.keys(config.env)) {
+            if (!mockEnvs[key]) {
+                mockEnvs[key] = "mock_value";
+            }
+        }
+    }
+    // Fetch available tools from the upstream MCP server
+    const { client: upstreamClient, closeConnection } = await getMcpClient(config, mockEnvs);
+    let upstreamTools;
+    try {
+        const result = await upstreamClient.listTools();
+        upstreamTools = result.tools;
+    }
+    finally {
+        await closeConnection();
+    }
+    // Ensure each tool's inputSchema allows additional properties.
+    // VSCode's AJV validator defaults to additionalProperties:false when
+    // the field is missing, causing "must NOT have additional properties".
+    for (const tool of upstreamTools) {
+        if (tool.inputSchema && !("additionalProperties" in tool.inputSchema)) {
+            tool.inputSchema.additionalProperties = true;
+        }
+    }
+    // Build a map of tool name → allowed property keys for argument filtering
+    const toolPropertyKeys = new Map();
+    for (const tool of upstreamTools) {
+        toolPropertyKeys.set(tool.name, new Set(Object.keys((_b = (_a = tool.inputSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {})));
+    }
+    const server = new Server({ name: `mcpsdk-gateway/${packageName}`, version: "1.0.0" }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        console.log(`[MCP Gateway] tools/list for ${packageName}: returning ${upstreamTools.length} tools`);
+        return { tools: upstreamTools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: rawArgs } = request.params;
+        // Filter to only schema-defined properties
+        const allowedKeys = toolPropertyKeys.get(name);
+        let args = rawArgs;
+        if (allowedKeys && args) {
+            const filtered = {};
+            for (const [k, v] of Object.entries(args)) {
+                if (allowedKeys.has(k)) {
+                    filtered[k] = v;
+                }
+            }
+            args = filtered;
+        }
+        // Read envs from the shared session ref (always up-to-date)
+        const envs = sessionRef.envs;
+        console.log(`[MCP Gateway] tools/call ${packageName}/${name}`, JSON.stringify(args).slice(0, 300), `envKeys=[${Object.keys(envs).join(",")}]`);
+        const { client, closeConnection: closeUpstream } = await getMcpClient(config, envs);
+        try {
+            const result = await client.callTool({ name, arguments: args });
+            return result;
+        }
+        finally {
+            await closeUpstream();
+        }
+    });
+    return { server, tools: upstreamTools };
+}
+/**
+ * Main request handler for the MCP Gateway.
+ */
+export function createMcpGatewayHandler(repository) {
+    return async (req, res, packageName) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, mcp-session-id, x-mcp-env-*");
+        res.setHeader("Access-Control-Expose-Headers", "mcp-session-id");
+        if (req.method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        let config;
+        try {
+            config = repository.getPackageConfig(packageName);
+        }
+        catch (_a) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: `Package '${packageName}' not found` }));
+            return;
+        }
+        const reqEnvs = extractEnvFromHeaders(req);
+        const sessionId = req.headers["mcp-session-id"];
+        console.log(`[MCP Gateway] ${req.method} ${req.url} session=${sessionId !== null && sessionId !== void 0 ? sessionId : "(new)"}`, `envKeys=[${Object.keys(reqEnvs).join(",")}]`);
+        // Existing session — merge any new env vars and delegate
+        if (sessionId && sessions.has(sessionId)) {
+            const session = sessions.get(sessionId);
+            if (session) {
+                // Merge env vars from this request into the session
+                Object.assign(session.envs, reqEnvs);
+                await session.transport.handleRequest(req, res);
+                return;
+            }
+        }
+        if (sessionId && !sessions.has(sessionId)) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Session not found or expired" }));
+            return;
+        }
+        // New session
+        try {
+            // Shared mutable ref so the tools/call handler always sees latest envs
+            const sessionRef = { envs: Object.assign({}, reqEnvs) };
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+                onsessioninitialized: (newSessionId) => {
+                    sessions.set(newSessionId, {
+                        transport,
+                        server: mcpServer,
+                        packageName,
+                        config,
+                        envs: sessionRef.envs,
+                        createdAt: Date.now(),
+                    });
+                },
+                onsessionclosed: (closedSessionId) => {
+                    sessions.delete(closedSessionId);
+                },
+                enableJsonResponse: true,
+            });
+            const { server: mcpServer } = await createProxyServer(packageName, config, sessionRef);
+            await mcpServer.connect(transport);
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error(`[MCP Gateway] Error for ${packageName}:`, error);
+            if (!res.headersSent) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({
+                    error: `Failed to initialize MCP gateway for ${packageName}`,
+                    message: error instanceof Error ? error.message : "Unknown error",
+                }));
+            }
+        }
+    };
+}

package/indexes/packages-list.json

@@ -56693,8 +56693,9 @@
     }
   },
   "supercolony-mcp": {
-    "path": "finance-fintech/supercolony-mcp.json",
     "category": "finance-fintech",
+    "path": "finance-fintech/supercolony-mcp.json",
+    "validated": true,
     "tools": {
       "supercolony_read_feed": {
         "name": "supercolony_read_feed",
@@ -56724,13 +56725,12 @@
         "name": "supercolony_build_agent",
         "description": "Get the complete integration guide for building an AI agent that joins SuperColony. Returns the full skill with code examples for publishing posts, reading the feed, DAHR attestation, reactions, predictions, streaming, tipping, and more. Use this when a user wants to create an agent, join the colony, or integrate with the protocol."
       }
-    },
-    "validated": true
+    }
   },
   "xquik": {
-    "path": "search-data-extraction/xquik.json",
     "category": "search-data-extraction",
-    "tools": {},
-    "validated": false
+    "path": "search-data-extraction/xquik.json",
+    "validated": false,
+    "tools": {}
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolsdk.ai/registry",
-  "version": "1.0.168",
+  "version": "1.0.169",
   "description": "An Open, Structured, and Standard Registry for MCP Servers and Packages.",
   "keywords": [
     "mcp",