@letoribo/mcp-graphql-enhanced 3.5.0 → 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,71 +355,129 @@ 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");
 }
 // --- STARTUP ---
 async function main() {
-    if (env.ENABLE_HTTP) {
+    const rawEnableHttp = process.env.ENABLE_HTTP;
+    // Determine if we should open the HTTP port.
+    // 1. Check if we're not running inside the MCP Inspector.
+    // 2. Ensure the user hasn't explicitly disabled HTTP (ENABLE_HTTP="false").
+    const isInspector = !!(process.env.MCP_INSPECTOR || process.env.INSPECTOR_PORT);
+    const shouldOpenPort = rawEnableHttp !== "false" && !isInspector;
+    if (shouldOpenPort) {
         const serverHttp = node_http_1.default.createServer(handleHttpRequest);
+        // Error handling to prevent crashes if the port is already in use
+        serverHttp.on('error', (e) => {
+            if (e.code !== 'EADDRINUSE')
+                console.error(`[HTTP-ERROR] ${e.message}`);
+        });
         serverHttp.listen(env.MCP_PORT, () => {
-            console.error(`[HTTP] Server started on http://localhost:${env.MCP_PORT}`);
-            console.error(`🎨 GraphiQL IDE: http://localhost:${env.MCP_PORT}/graphiql`);
-            console.error(`🤖 MCP Endpoint: http://localhost:${env.MCP_PORT}/mcp\n`);
+            // Log URLs only if HTTP is explicitly enabled
+            if (env.ENABLE_HTTP === true) {
+                console.error(`[HTTP] Server started on http://localhost:${env.MCP_PORT}`);
+                console.error(`🎨 GraphiQL IDE: http://localhost:${env.MCP_PORT}/graphiql`);
+            }
+            console.error(`🤖 MCP Endpoint: http://localhost:${env.MCP_PORT}/mcp`);
         });
     }
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
-    console.error(`[STDIO] MCP Server "${env.NAME}" v${getVersion()} started`);
-    getSchema().catch(e => console.error(`[SCHEMA] Warning: Preload failed: ${e.message}`));
+    // Maintain quiet mode when running inside the Inspector to avoid protocol interference
+    if (!isInspector) {
+        console.error(`[STDIO] MCP Server "${env.NAME}" v${getVersion()} started`);
+    }
+    getSchema().catch(e => {
+        if (!isInspector)
+            console.error(`[SCHEMA] Warning: ${e.message}`);
+    });
 }
 process.on('SIGINT', () => process.exit(0));
 process.on('SIGTERM', () => process.exit(0));

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.0"
+	"version": "3.6.0"
 }