@letoribo/mcp-graphql-enhanced 3.5.1 → 3.7.0

package/dist/helpers/prompt-registry.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Universal prompt wrapper for MCP server
+ */
+export declare function registerPrompt(server: any, name: string, description: string, template: string): void;
+//# sourceMappingURL=prompt-registry.d.ts.map

package/dist/helpers/prompt-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-registry.d.ts","sourceRoot":"","sources":["../../src/helpers/prompt-registry.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAgB,cAAc,CAC1B,MAAM,EAAE,GAAG,EACX,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,QAenB"}

package/dist/helpers/prompt-registry.js

@@ -0,0 +1,22 @@
+"use strict";
+// src/helpers/prompt-registry.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPrompt = registerPrompt;
+/**
+ * Universal prompt wrapper for MCP server
+ */
+function registerPrompt(server, name, description, template) {
+    server.prompt(name, description, (args) => {
+        return {
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: template + (args?.focus ? ` Focus on: ${args.focus}` : "")
+                    }
+                }
+            ]
+        };
+    });
+}

package/dist/helpers/tool-registry.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Universal tool wrapper that registers tools for both MCP and HTTP Discovery.
+ * Handles Zod schema parsing to generate metadata for external clients.
+ */
+export declare function registerTool(server: any, toolHandlers: Map<string, (args: any) => Promise<any>>, registeredToolsMetadata: any[], name: string, description: string, schema: any, handler: (args: any) => Promise<any>): void;
+//# sourceMappingURL=tool-registry.d.ts.map

package/dist/helpers/tool-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-registry.d.ts","sourceRoot":"","sources":["../../src/helpers/tool-registry.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,YAAY,CACxB,MAAM,EAAE,GAAG,EACX,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC,EACtD,uBAAuB,EAAE,GAAG,EAAE,EAC9B,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,GAAG,EACX,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,QAwCvC"}

package/dist/helpers/tool-registry.js

@@ -0,0 +1,42 @@
+"use strict";
+// src/helpers/tool-registry.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTool = registerTool;
+/**
+ * Universal tool wrapper that registers tools for both MCP and HTTP Discovery.
+ * Handles Zod schema parsing to generate metadata for external clients.
+ */
+function registerTool(server, toolHandlers, registeredToolsMetadata, name, description, schema, handler) {
+    // 1. Official MCP Server registration
+    server.tool(name, description, schema, handler);
+    // 2. Map handler for internal HTTP routing
+    toolHandlers.set(name, handler);
+    // 3. Smart metadata generation for Discovery (HTTP list-tools)
+    registeredToolsMetadata.push({
+        name,
+        description,
+        inputSchema: {
+            type: "object",
+            properties: Object.fromEntries(Object.entries(schema).map(([key, value]) => {
+                // Recursive helper to extract type info from Zod objects
+                const getZodType = (v) => {
+                    const type = v?._def?.typeName?.replace('Zod', '').toLowerCase() || "string";
+                    if (type === 'array') {
+                        return {
+                            type: "array",
+                            items: { type: getZodType(v._def.type) }
+                        };
+                    }
+                    return { type };
+                };
+                const typeInfo = getZodType(value);
+                return [key, typeInfo];
+            })),
+            // Identify required fields by checking for ZodOptional or '?' in key
+            required: Object.keys(schema).filter(key => {
+                const val = schema[key];
+                return val?._def?.typeName !== 'ZodOptional' && !key.includes('?');
+            })
+        }
+    });
+}

package/dist/index.js

@@ -14,13 +14,15 @@ const graphql_1 = require("graphql");
 // Helper imports
 const deprecation_js_1 = require("./helpers/deprecation.js");
 const introspection_js_1 = require("./helpers/introspection.js");
+const tool_registry_js_1 = require("./helpers/tool-registry.js");
+const prompt_registry_js_1 = require("./helpers/prompt-registry.js");
 const getVersion = () => {
     try {
         const pkg = require("../package.json");
         return pkg.version;
     }
     catch {
-        return "3.2.1";
+        return "3.6.0";
     }
 };
 (0, deprecation_js_1.checkDeprecatedArguments)();
@@ -59,6 +61,11 @@ const server = new mcp_js_1.McpServer({
     name: env.NAME,
     version: getVersion(),
     description: "Start of the #mcp-graphql-enhanced channel on GraphQL server. Join here: https://discord.com/channels/622115132221685760/1348633379555184640"
+}, {
+    capabilities: {
+        prompts: {},
+        tools: {}
+    }
 });
 // --- CACHE STATE ---
 let cachedSDL = null;
@@ -198,8 +205,10 @@ 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 = [];
 /** * 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 +264,7 @@ const queryGraphqlHandler = async ({ query, variables, headers }) => {
     }
 };
 toolHandlers.set("query-graphql", queryGraphqlHandler);
-server.tool("query-graphql", "Execute a GraphQL query against the endpoint", {
+(0, tool_registry_js_1.registerTool)(server, toolHandlers, registeredToolsMetadata, "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,91 +331,134 @@ const introspectHandler = async ({ typeNames }) => {
     };
 };
 toolHandlers.set("introspect-schema", introspectHandler);
-server.tool("introspect-schema", "Introspect the GraphQL schema with optional type filtering", {
+(0, tool_registry_js_1.registerTool)(server, toolHandlers, registeredToolsMetadata, "introspect-schema", "Introspect the GraphQL schema with optional type filtering", {
     typeNames: zod_1.default.array(zod_1.default.string()).optional(),
 }, introspectHandler);
+// --- PROMPTS (The "Add from ..." buttons in Claude UI) ---
+// 1. Connection check
+(0, prompt_registry_js_1.registerPrompt)(server, "health-check", "Check if the GraphQL endpoint is alive", "Run 'query-graphql' with query '{ __typename }' to verify connection.");
+// 2. High-level overview
+(0, prompt_registry_js_1.registerPrompt)(server, "schema-overview", "List all available types", "Run 'introspect-schema' to see all types and entry points.");
+// 3. Data types analysis
+(0, prompt_registry_js_1.registerPrompt)(server, "list-scalars", "List all scalar types", "Run 'introspect-schema' and identify all scalars in the schema.");
 // --- 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) - ONLY if explicitly enabled
     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));
+        // Check our explicit flag
+        if (process.env.ENABLE_HTTP === 'true') {
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            return res.end((0, graphiql_js_1.renderGraphiQL)(env.ENDPOINT, env.HEADERS));
+        }
+        else {
+            // Forbidden if not explicitly enabled
+            res.writeHead(403, { 'Content-Type': 'text/plain' });
+            return res.end("Forbidden: GraphiQL UI is disabled. Start with ENABLE_HTTP=true to use it.");
+        }
     }
+    // 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() {
-    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 isHttpExplicitlyEnabled = process.env.ENABLE_HTTP === "true";
+    // Open HTTP port by default for MCP SSE, unless explicitly disabled
+    if (process.env.ENABLE_HTTP !== "false" && !isInspector) {
         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}`);
+            if (e.code === 'EADDRINUSE') {
+                console.error(`[HTTP-ERROR] Port ${env.MCP_PORT} is busy.`);
+            }
         });
         serverHttp.listen(env.MCP_PORT, () => {
-            // 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`);
+            // All-in-one status report
+            console.error(`[SYSTEM] Server "${env.NAME}" v${getVersion()} active`);
+            console.error(`🤖 MCP SSE: http://localhost:${env.MCP_PORT}/mcp`);
+            // Show UI only if explicitly requested
+            if (isHttpExplicitlyEnabled) {
+                console.error(`🎨 GraphiQL UI: 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);
-    // 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}`);
-    });
+    getSchema().catch(() => { });
 }
 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.1"
+	"version": "3.7.0"
 }