@letoribo/mcp-graphql-enhanced 3.5.1 → 3.6.0

package/dist/index.js

@@ -198,8 +198,41 @@ async function performUpdate(force) {
         updatePromise = null;
     }
 }
-// --- TOOL HANDLERS ---
+// --- TOOL REGISTRY ---
 const toolHandlers = new Map();
+// This will store schemas for our dynamic HTTP 'list-tools' response
+const registeredToolsMetadata = [];
+/**
+ * Helper to register tools in both MCP Server and our local registry
+ * Handles both plain objects and Zod schemas
+ */
+function registerTool(name, description, schema, handler) {
+    // 1. Register in official MCP Server
+    server.tool(name, description, schema, handler);
+    // 2. Save handler for our HTTP routing
+    toolHandlers.set(name, handler);
+    // 3. Store metadata for dynamic Discovery
+    // We treat 'schema' as a plain object for the JSON output
+    registeredToolsMetadata.push({
+        name,
+        description,
+        inputSchema: {
+            type: "object",
+            properties: Object.fromEntries(Object.entries(schema).map(([key, value]) => {
+                // Detect type from Zod or default to string
+                const typeName = value?._def?.typeName
+                    ? value._def.typeName.replace('Zod', '').toLowerCase()
+                    : "string";
+                return [key, { type: typeName }];
+            })),
+            // Assume all fields in the object are required unless specified
+            required: Object.keys(schema).filter(key => {
+                const val = schema[key];
+                return val?._def?.typeName !== 'ZodOptional' && !key.includes('?');
+            })
+        }
+    });
+}
 /** * executionLogs stores the last 5 GraphQL operations.
  * This allows the AI to "inspect" its own generated queries and the raw data
  * for debugging or bridging to 3D visualization tools.
@@ -255,7 +288,7 @@ const queryGraphqlHandler = async ({ query, variables, headers }) => {
     }
 };
 toolHandlers.set("query-graphql", queryGraphqlHandler);
-server.tool("query-graphql", "Execute a GraphQL query against the endpoint", {
+registerTool("query-graphql", "Execute a GraphQL query against the endpoint", {
     query: zod_1.default.string(),
     variables: zod_1.default.string().optional(),
     headers: zod_1.default.string().optional(),
@@ -322,54 +355,92 @@ const introspectHandler = async ({ typeNames }) => {
     };
 };
 toolHandlers.set("introspect-schema", introspectHandler);
-server.tool("introspect-schema", "Introspect the GraphQL schema with optional type filtering", {
+registerTool("introspect-schema", "Introspect the GraphQL schema with optional type filtering", {
     typeNames: zod_1.default.array(zod_1.default.string()).optional(),
 }, introspectHandler);
 // --- HTTP SERVER LOGIC ---
 async function handleHttpRequest(req, res) {
+    // Standard CORS headers for cross-origin compatibility
     res.setHeader('Access-Control-Allow-Origin', '*');
     res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+    // Handle preflight requests
     if (req.method === 'OPTIONS') {
         res.writeHead(204);
         res.end();
         return;
     }
     const url = new URL(req.url || '', `http://${req.headers.host}`);
-    // NEW FEATURE: Web GUI for Humans
+    // Serve Web GUI (GraphiQL)
     if (req.method === 'GET' && (url.pathname === '/' || url.pathname === '/graphiql')) {
         res.writeHead(200, { 'Content-Type': 'text/html' });
-        // Pass env.HEADERS to the explorer
         return res.end((0, graphiql_js_1.renderGraphiQL)(env.ENDPOINT, env.HEADERS));
     }
+    // Process MCP JSON-RPC Endpoint
     if (url.pathname === '/mcp' && req.method === 'POST') {
         let body = '';
         req.on('data', chunk => { body += chunk; });
         req.on('end', async () => {
+            let requestId = null; // Defined early to be accessible in catch block
             try {
-                const { method, params, id } = JSON.parse(body);
+                const request = JSON.parse(body);
+                const { method, id, params } = request;
+                requestId = id;
                 console.error(`[HTTP-RPC] Method: ${method} | ID: ${id}`);
-                const handler = toolHandlers.get(method);
+                // --- DYNAMIC DISCOVERY ---
+                if (method === "list-tools" || method === "tools/list") {
+                    // Просто отдаем то, что накопили в нашем реестре при регистрации
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    return res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        id: requestId,
+                        result: { tools: registeredToolsMetadata }
+                    }));
+                }
+                // --- TOOL EXECUTION (CALL) ---
+                let targetMethod = method;
+                let toolArgs = params;
+                // Support both direct calls and standard MCP "call-tool" structure
+                if (method === "call-tool" || method === "tools/call") {
+                    targetMethod = params.name;
+                    toolArgs = params.arguments;
+                }
+                const handler = toolHandlers.get(targetMethod);
                 if (!handler) {
                     res.writeHead(404);
-                    return res.end(JSON.stringify({ jsonrpc: '2.0', id, error: { code: -32601, message: "Method not found" } }));
+                    return res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        id: requestId,
+                        error: { code: -32601, message: `Tool ${targetMethod} not found` }
+                    }));
                 }
-                const result = await handler(params);
+                // Execute the actual business logic for the tool
+                const result = await handler(toolArgs);
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ jsonrpc: '2.0', id, result }));
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: requestId,
+                    result
+                }));
             }
             catch (e) {
                 console.error(`[HTTP-ERROR] ${e.message}`);
                 res.writeHead(500);
-                res.end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32603, message: "Internal Error" } }));
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: requestId,
+                    error: { code: -32603, message: e.message || "Internal Server Error" }
+                }));
             }
         });
         return;
     }
+    // Health check endpoint for monitoring
     if (url.pathname === '/health') {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         return res.end(JSON.stringify({ status: "ok", server: env.NAME }));
     }
+    // Default 404 for unknown paths
     res.writeHead(404);
     res.end("Not Found");
 }

package/package.json

@@ -35,7 +35,7 @@
 		"format": "prettier --write ."
 	},
 	"dependencies": {
-		"@modelcontextprotocol/sdk": "^1.20.1",
+		"@modelcontextprotocol/sdk": "^1.27.1",
 		"graphql": "^16.11.0",
 		"yargs": "17.7.2",
 		"zod": "3.25.30",
@@ -50,5 +50,5 @@
 		"tsx": "^4.21.0",
 		"typescript": "5.8.3"
 	},
-	"version": "3.5.1"
+	"version": "3.6.0"
 }