@letoribo/mcp-graphql-enhanced 2.3.1 → 2.3.2

package/README.md

@@ -42,7 +42,7 @@ curl http://localhost:6274/health
 
 # Example: Test the query tool via JSON-RPC (using port 6275 if 6274 was busy)
 curl -X POST http://localhost:6275/mcp -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","method":"query-graphql","params":{"query":"query { __typename }"},"id":1}'
-```
+
 ## 🔍 Filtered Introspection (New!)
 Avoid 50k-line schema dumps. Ask for only what you need:
 ```@introspect-schema typeNames ["Query", "User"]```

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-declare const app: import("express-serve-static-core").Express;
-export default app;
+#!/usr/bin/env node
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA2UA,QAAA,MAAM,GAAG,6CAAY,CAAC;AA0CtB,eAAe,GAAG,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -1,349 +1,361 @@
+#!/usr/bin/env node
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const express_1 = __importDefault(require("express"));
-// CRITICAL FIX: Explicitly import the CJS file path and use HttpLink for Vercel/NodeNext environments.
-// NOTE: We import it as 'any' to temporarily bypass the missing type declaration warning
-// for '@apollo/client/core/core.cjs', but you must install the @types/express package.
-const apolloModule = __importStar(require("@apollo/client/core/core.cjs"));
-const graphql_1 = require("graphql");
-// -----------------------------------------------------------------------------------
-// 1. GraphQL Endpoint Configuration
-const MCP_GRAPHQL_ENDPOINT = process.env.ENDPOINT ||
-    process.env.MCP_GRAPHQL_ENDPOINT ||
-    'https://countries.trevorblades.com/';
-// Initialize the client immediately
-let client;
-let coreExports; // Variable to hold the correctly resolved Apollo components
-try {
-    // Dynamically determine the correct namespace for Apollo components.
-    // This is necessary because CJS module formats often wrap exports differently.
-    if (apolloModule.HttpLink) {
-        coreExports = apolloModule;
-        console.log('[Setup] Apollo exports resolved at the root level.');
-    }
-    else if (apolloModule.default && apolloModule.default.HttpLink) {
-        coreExports = apolloModule.default;
-        console.log('[Setup] Apollo exports resolved nested under .default.');
-    }
-    else {
-        throw new Error('Could not resolve Apollo Client components (HttpLink, ApolloClient) from imported module.');
-    }
-    // Now use coreExports for all constructors and functions
-    const httpLink = new coreExports.HttpLink({
-        uri: MCP_GRAPHQL_ENDPOINT,
-        // Pass the global fetch function
-        fetch: fetch,
-    });
-    client = new coreExports.ApolloClient({
-        link: httpLink,
-        cache: new coreExports.InMemoryCache(),
-    });
-    console.log('[Setup] Apollo Client Initialized.');
-}
-catch (error) {
-    console.error('[Setup] CRITICAL RUNTIME ERROR: Failed to initialize Apollo Client:', error instanceof Error ? error.message : String(error));
-}
-// --- GraphQL Introspection Helpers (Using global fetch) ---
-/**
- * Executes a GraphQL introspection query against a remote endpoint.
- */
-const executeIntrospection = async (endpoint, headers, query) => {
-    let response;
+const node_http_1 = __importDefault(require("node:http"));
+const { McpServer } = require("@modelcontextprotocol/sdk/server/mcp.js");
+const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
+const { parse } = require("graphql/language");
+const z = require("zod").default;
+const { checkDeprecatedArguments } = require("./helpers/deprecation.js");
+const { introspectEndpoint, introspectLocalSchema, introspectSchemaFromUrl, introspectTypes, } = require("./helpers/introspection.js");
+const getVersion = () => {
+    const pkg = require("../package.json");
+    return pkg.version;
+};
+checkDeprecatedArguments();
+const EnvSchema = z.object({
+    NAME: z.string().default("mcp-graphql-enhanced"),
+    ENDPOINT: z.preprocess((val) => (typeof val === 'string' ? val.trim() : val), z.string().url("ENDPOINT must be a valid URL (e.g., https://example.com/graphql)")).default("https://mcp-neo4j-discord.vercel.app/api/graphiql"),
+    ALLOW_MUTATIONS: z
+        .enum(["true", "false"])
+        .transform((value) => value === "true")
+        .default("false"),
+    HEADERS: z
+        .string()
+        .default("{}")
+        .transform((val) => {
+        try {
+            return JSON.parse(val);
+        }
+        catch (e) {
+            throw new Error("HEADERS must be a valid JSON string");
+        }
+    }),
+    SCHEMA: z.string().optional(),
+    MCP_PORT: z.preprocess((val) => (val ? parseInt(val) : 6274), z.number().int().min(1024).max(65535)).default(6274),
+});
+const env = EnvSchema.parse(process.env);
+const server = new McpServer({
+    name: env.NAME,
+    version: getVersion(),
+    description: `GraphQL MCP server for ${env.ENDPOINT}`,
+});
+server.resource("graphql-schema", new URL(env.ENDPOINT).href, async (uri) => {
     try {
-        // Use the global fetch function
-        response = await fetch(endpoint, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...headers,
-            },
-            body: JSON.stringify({ query }),
-        });
-    }
-    catch (networkError) {
-        console.error('NETWORK ERROR during introspection:', networkError);
-        throw new Error(`Failed to connect to GraphQL endpoint at ${endpoint}. Network error: ${networkError instanceof Error ? networkError.message : String(networkError)}`);
-    }
-    if (!response.ok) {
-        const responseText = await response.text();
-        throw new Error(`Introspection query failed with status ${response.status} (${response.statusText}). Response: ${responseText.substring(0, 200)}...`);
+        let schema;
+        if (env.SCHEMA) {
+            if (env.SCHEMA.startsWith("http://") ||
+                env.SCHEMA.startsWith("https://")) {
+                schema = await introspectSchemaFromUrl(env.SCHEMA);
+            }
+            else {
+                schema = await introspectLocalSchema(env.SCHEMA);
+            }
+        }
+        else {
+            schema = await introspectEndpoint(env.ENDPOINT, env.HEADERS);
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: schema,
+                },
+            ],
+        };
     }
-    const json = await response.json();
-    if (json.errors) {
-        throw new Error(`GraphQL errors during introspection: ${JSON.stringify(json.errors)}`);
+    catch (error) {
+        throw new Error(`Failed to get GraphQL schema: ${error}`);
     }
-    return json.data;
-};
-/**
- * Introspects the endpoint and returns the full schema string (SDL).
- */
-const introspectEndpoint = async (endpoint, headers) => {
-    const data = await executeIntrospection(endpoint, headers, (0, graphql_1.getIntrospectionQuery)());
-    const schema = (0, graphql_1.buildClientSchema)(data);
-    return (0, graphql_1.printSchema)(schema);
-};
-/**
- * Introspects the endpoint and returns an annotated schema, optionally filtering root fields.
- */
-const introspectTypes = async (endpoint, headers, typeNames) => {
-    const data = await executeIntrospection(endpoint, headers, (0, graphql_1.getIntrospectionQuery)());
-    const schema = (0, graphql_1.buildClientSchema)(data);
-    // Fallback to full schema if no typeNames are provided or if filtering is not feasible
-    if (!typeNames || typeNames.length === 0) {
-        return `--- Full Schema Introspection ---\nEndpoint: ${endpoint}\n\n${(0, graphql_1.printSchema)(schema)}`;
-    }
-    const requestedTypeSet = new Set(typeNames.map(name => name.trim()));
-    let filteredSchema = `--- Annotated Schema Introspection ---\nEndpoint: ${endpoint}\nRequested Types: ${typeNames.join(', ')}\n\n`;
-    // 1. Prune the Query type fields to only include those that resolve to requested types
-    const queryType = schema.getQueryType();
-    if (queryType) {
-        const fields = queryType.getFields();
-        const keptQueryFields = [];
-        // Flag: If the user requested the "Query" type itself, include all root fields for utility.
-        const includeAllQueryFields = requestedTypeSet.has(queryType.name);
-        Object.keys(fields).forEach(fieldName => {
-            const field = fields[fieldName];
-            const returnType = (0, graphql_1.getNamedType)(field.type);
-            // Keep the field if:
-            // 1. Its return type is one of the requested types, OR
-            // 2. The user explicitly requested the "Query" type itself.
-            if (includeAllQueryFields || requestedTypeSet.has(returnType.name)) {
-                // Build a representation of the field including arguments and full type string
-                const args = field.args.map(arg => `${arg.name}: ${arg.type.toString()}`).join(', ');
-                keptQueryFields.push(`  ${fieldName}${args ? `(${args})` : ''}: ${field.type.toString()}`);
+});
+const toolHandlers = new Map();
+const introspectSchemaHandler = async ({ typeNames, descriptions = true, directives = true }) => {
+    try {
+        if (typeNames && typeNames.length > 0) {
+            const filtered = await introspectTypes(env.ENDPOINT, env.HEADERS, typeNames);
+            return { content: [{ type: "text", text: filtered }] };
+        }
+        else {
+            let schema;
+            if (env.SCHEMA) {
+                if (env.SCHEMA.startsWith("http://") || env.SCHEMA.startsWith("https://")) {
+                    schema = await introspectSchemaFromUrl(env.SCHEMA);
+                }
+                else {
+                    schema = await introspectLocalSchema(env.SCHEMA);
+                }
             }
-        });
-        // CRITICAL FIX: Ensure the Annotated Query block is output if fields were kept.
-        if (keptQueryFields.length > 0) {
-            filteredSchema += `type Query { \n${keptQueryFields.join('\n')}\n\n`;
+            else {
+                schema = await introspectEndpoint(env.ENDPOINT, env.HEADERS);
+            }
+            return { content: [{ type: "text", text: schema }] };
         }
     }
-    // 2. Add the definition of every requested type (and their dependencies for robustness)
-    filteredSchema += `--- Full Type Definitions (Including Dependencies) ---\n\n`;
-    filteredSchema += (0, graphql_1.printSchema)(schema);
-    return filteredSchema;
-};
-/**
- * Fetches a schema file from a remote URL.
- */
-const introspectSchemaFromUrl = async (schemaUrl) => {
-    // Use the global fetch function
-    const response = await fetch(schemaUrl);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch schema from ${schemaUrl}: ${response.statusText}`);
+    catch (error) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Introspection failed: ${error}` }],
+        };
     }
-    return response.text();
-};
-/**
- * Handles local file loading (not supported on Vercel).
- */
-const introspectLocalSchema = async (filePath) => {
-    throw new Error("Local schema file loading is not supported in the Vercel environment.");
 };
-// --- JSON-RPC Handler ---
-/**
- * Handles incoming JSON-RPC 2.0 requests.
- */
-async function handleJsonRpc(reqBody) {
-    const { method, params, id } = reqBody;
-    // Guard clause to ensure Apollo Client was initialized successfully
-    if (!client) {
-        console.error('Apollo Client is unavailable.');
+toolHandlers.set("introspect-schema", introspectSchemaHandler);
+server.tool("introspect-schema", "Introspect the GraphQL schema. Optionally filter to specific types.", {
+    typeNames: z.array(z.string()).optional().describe("A list of specific type names to filter the introspection."),
+    descriptions: z.boolean().optional().default(true),
+    directives: z.boolean().optional().default(true),
+}, introspectSchemaHandler);
+const queryGraphqlHandler = async ({ query, variables, headers }) => {
+    try {
+        const parsedQuery = parse(query);
+        const isMutation = parsedQuery.definitions.some((def) => def.kind === "OperationDefinition" && def.operation === "mutation");
+        if (isMutation && !env.ALLOW_MUTATIONS) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: "Mutations are not allowed unless you enable them in the configuration. Please use a query operation instead.",
+                    },
+                ],
+            };
+        }
+    }
+    catch (error) {
         return {
-            jsonrpc: '2.0',
-            id: id || null,
-            error: {
-                code: -32000, // Server error
-                message: 'Server failed to initialize Apollo Client.',
-            },
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Invalid GraphQL query: ${error}`,
+                },
+            ],
         };
     }
-    // --- 1. Query GraphQL ---
-    if (method === 'query-graphql' && params && params.query) {
-        try {
-            const { query } = params;
-            // Execute the GraphQL query against the configured endpoint
-            const result = await client.query({
-                // Note: Using 'gql' via coreExports
-                query: coreExports.gql(query),
-                fetchPolicy: 'no-cache', // Ensure fresh data on every call
-            });
-            // CRITICAL FIX:
-            // A successful JSON-RPC response must contain the actual data under the 'result' key.
-            // The actual GraphQL data is located in the Apollo result's 'data' property.
-            if (result.data) {
-                return {
-                    jsonrpc: '2.0',
-                    id: id,
-                    // Map the raw GraphQL data to the JSON-RPC 'result' field
-                    result: result.data,
-                };
+    try {
+        const toolHeaders = headers
+            ? JSON.parse(headers)
+            : {};
+        const allHeaders = {
+            "Content-Type": "application/json",
+            ...env.HEADERS,
+            ...toolHeaders,
+        };
+        let parsedVariables = null;
+        if (variables) {
+            if (typeof variables === 'string') {
+                parsedVariables = JSON.parse(variables);
             }
-            // Handle GraphQL errors returned in the result object (e.g., validation/execution errors)
-            if (result.errors) {
-                console.error('GraphQL Execution Errors Found:', result.errors);
-                // Return a JSON-RPC Error object if GraphQL execution failed
-                return {
-                    jsonrpc: "2.0",
-                    error: {
-                        code: -32000, // Standard JSON-RPC error code for Server Error
-                        message: "GraphQL Execution Error",
-                        data: result.errors
-                    },
-                    id: id
-                };
+            else {
+                parsedVariables = variables;
             }
-            // Fallback for unexpected empty result
+        }
+        const response = await fetch(env.ENDPOINT, {
+            method: "POST",
+            headers: allHeaders,
+            body: JSON.stringify({
+                query,
+                variables: parsedVariables,
+            }),
+        });
+        if (!response.ok) {
+            const responseText = await response.text();
             return {
-                jsonrpc: '2.0',
-                id: id,
-                error: {
-                    code: -32603, // Internal error
-                    message: 'Error executing GraphQL query: Response was empty.',
-                },
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `GraphQL request failed: ${response.statusText}\n${responseText}`,
+                    },
+                ],
             };
         }
-        catch (error) {
-            console.error('GraphQL Execution Error (Catch Block):', error);
+        const rawData = await response.json();
+        const data = rawData;
+        if (data.errors && data.errors.length > 0) {
             return {
-                jsonrpc: '2.0',
-                id: id,
-                error: {
-                    code: -32603, // Internal error
-                    message: 'Error executing GraphQL query',
-                    data: error.message,
-                },
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `GraphQL errors: ${JSON.stringify(data.errors, null, 2)}`,
+                    },
+                ],
             };
         }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(data, null, 2),
+                },
+            ],
+        };
     }
-    // --- 2. Introspect Schema ---
-    if (method === 'introspect-schema') {
+    catch (error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to execute GraphQL query: ${error}`,
+                },
+            ],
+        };
+    }
+};
+toolHandlers.set("query-graphql", queryGraphqlHandler);
+server.tool("query-graphql", "Query a GraphQL endpoint with the given query and variables. Optionally pass headers (e.g., for Authorization).", {
+    query: z.string(),
+    variables: z.string().optional(),
+    headers: z
+        .string()
+        .optional()
+        .describe("Optional JSON string of headers to include, e.g., {\"Authorization\": \"Bearer ...\"}"),
+}, queryGraphqlHandler);
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            resolve(body);
+        });
+        req.on('error', reject);
+    });
+}
+async function handleHttpRequest(req, res) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    if (url.pathname === '/health' && req.method === 'GET') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ status: 'ok', server: env.NAME }));
+        return;
+    }
+    if (url.pathname === '/mcp' && req.method === 'POST') {
+        let rawBody;
+        let request;
         try {
-            // Default to using the main endpoint
-            let schemaSource = MCP_GRAPHQL_ENDPOINT;
-            let resultText;
-            const headers = {};
-            // Check if a remote schema URL is provided
-            if (params?.schemaUrl) {
-                resultText = await introspectSchemaFromUrl(params.schemaUrl);
-            }
-            // Check if typeNames are provided for filtered introspection
-            else if (params?.typeNames) {
-                resultText = await introspectTypes(schemaSource, headers, params.typeNames);
+            rawBody = await readBody(req);
+            request = JSON.parse(rawBody);
+        }
+        catch (e) {
+            console.error("HTTP MCP Parse Error:", e);
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                jsonrpc: '2.0',
+                id: null,
+                error: { code: -32700, message: 'Parse Error: Invalid JSON received in request body.' }
+            }));
+            return;
+        }
+        try {
+            const { method, params, id } = request;
+            if (!method || typeof id === 'undefined') {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: id || null,
+                    error: { code: -32600, message: 'Invalid JSON-RPC Request structure (missing method or id).' }
+                }));
+                return;
             }
-            // Default: Full introspection
-            else {
-                resultText = await introspectEndpoint(schemaSource, headers);
+            const handler = toolHandlers.get(method);
+            if (!handler) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: id,
+                    error: { code: -32601, message: `Method not found: ${method}` }
+                }));
+                return;
             }
-            // Introspection methods return the schema as a string, which is correct
-            // for the 'text' type output used here.
-            return {
+            const result = await handler(params);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
                 jsonrpc: '2.0',
                 id: id,
-                result: {
-                    content: [
-                        {
-                            type: 'text',
-                            text: resultText,
-                        },
-                    ],
-                },
-            };
+                result: result
+            }));
         }
         catch (error) {
-            console.error('Introspection Error:', error);
-            return {
+            console.error("HTTP MCP Execution Error:", error);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
                 jsonrpc: '2.0',
-                id: id,
-                error: {
-                    code: -32603, // Internal error
-                    message: 'Error during schema introspection',
-                    data: error.message,
-                },
-            };
+                id: request?.id || null,
+                error: { code: -32603, message: 'Internal server error during tool execution.' }
+            }));
         }
+        return;
     }
-    // --- 3. Handle unsupported method ---
-    return {
-        jsonrpc: '2.0',
-        id: id || null,
-        error: {
-            code: -32601, // Method not found
-            message: `Method not found: ${method}`,
-        },
-    };
+    res.writeHead(404, { 'Content-Type': 'text/plain' });
+    res.end('Not Found. Use POST /mcp for JSON-RPC or GET /health.');
 }
-// --- Express App Setup ---
-const app = (0, express_1.default)();
-// Use express.json()
-app.use(express_1.default.json());
-// **CRITICAL FIX FOR LOCAL DEVELOPMENT (vercel dev):**
-// When running locally, the full path /mcp is passed to Express.
-app.post('/mcp', async (req, res) => {
-    const response = await handleJsonRpc(req.body);
-    res.json(response);
-});
-// **CRITICAL FIX FOR VERCEL PRODUCTION:**
-// When deployed, Vercel strips the /mcp prefix, so the function receives the path as '/'.
-app.post('/', async (req, res) => {
-    const response = await handleJsonRpc(req.body);
-    res.json(response);
-});
-// Health check endpoints for both environments
-// FIX: Changed unused 'req' parameters to '_req' to silence the linting warning.
-app.get('/health', (_req, res) => {
-    // Note: Checking client status (it will be an instance of ApolloClient if successful)
-    if (client && client instanceof coreExports.ApolloClient) {
-        res.status(200).send('OK');
-    }
-    else {
-        res.status(500).send('Initialization Failed');
-    }
-});
-app.get('/mcp/health', (_req, res) => {
-    // This route is primarily for local testing convenience
-    if (client && client instanceof coreExports.ApolloClient) {
-        res.status(200).send('OK');
-    }
-    else {
-        res.status(500).send('Initialization Failed');
-    }
+/**
+ * Tries to listen on a given port, automatically retrying on the next port if EADDRINUSE occurs.
+ * @param server - The HTTP server instance.
+ * @param port - The port to attempt binding to.
+ * @param maxRetries - Maximum number of retries.
+ * @param attempt - Current attempt number.
+ * @returns Resolves with the bound server instance.
+ */
+function tryListen(server, port, maxRetries = 5, attempt = 0) {
+    return new Promise((resolve, reject) => {
+        if (attempt >= maxRetries) {
+            reject(new Error(`Failed to bind HTTP server after ${maxRetries} attempts, starting from port ${env.MCP_PORT}.`));
+            return;
+        }
+        if (port > 65535) {
+            reject(new Error(`Exceeded maximum port number (65535) during retry.`));
+            return;
+        }
+        const errorHandler = (err) => {
+            server.removeListener('error', errorHandler); // Remove listener to prevent memory leak
+            if (err.code === 'EADDRINUSE') {
+                const nextPort = port + 1;
+                // Use console.error so it appears in the Inspector log
+                console.error(`[HTTP] Port ${port} is in use (EADDRINUSE). Retrying on ${nextPort}...`);
+                server.close(() => {
+                    // Recursively call tryListen with the next port
+                    resolve(tryListen(server, nextPort, maxRetries, attempt + 1));
+                });
+            }
+            else {
+                reject(err);
+            }
+        };
+        server.on('error', errorHandler);
+        server.listen(port, () => {
+            server.removeListener('error', errorHandler); // success, remove the error listener
+            console.error(`[HTTP] Started server on http://localhost:${port}. Listening for POST /mcp requests.`);
+            resolve(server);
+        });
+    });
+}
+function startHttpTransport() {
+    const serverInstance = node_http_1.default.createServer(handleHttpRequest);
+    tryListen(serverInstance, env.MCP_PORT).catch((error) => {
+        console.error(`[HTTP] Failed to start HTTP transport: ${error.message}`);
+    });
+}
+async function main() {
+    const stdioTransport = new StdioServerTransport();
+    await server.connect(stdioTransport);
+    startHttpTransport();
+    console.error(`[STDIO] Started graphql mcp server ${env.NAME} for endpoint: ${env.ENDPOINT}`);
+}
+main().catch((error) => {
+    console.error(`Fatal error in main(): ${error}`);
+    process.exit(1);
 });
-// Export the app instance for Vercel
-exports.default = app;

package/package.json

@@ -43,14 +43,11 @@
 	},
 	"devDependencies": {
 		"@graphql-tools/schema": "^10.0.23",
-		"@types/express": "^5.0.5",
-		"@types/graphql": "^14.2.3",
 		"@types/node": "^24.7.2",
 		"@types/yargs": "17.0.33",
-		"graphql-yoga": "^5.13.5",
 		"prettier": "^3.6.2",
 		"ts-node": "^10.9.2",
 		"typescript": "5.8.3"
 	},
-	"version": "2.3.1"
+	"version": "2.3.2"
 }