@letoribo/mcp-graphql-enhanced 2.3.0 → 2.3.1

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 @@
-#!/usr/bin/env node
-export {};
+declare const app: import("express-serve-static-core").Express;
+export default app;
 //# 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":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA2UA,QAAA,MAAM,GAAG,6CAAY,CAAC;AA0CtB,eAAe,GAAG,CAAC"}

package/dist/index.js

@@ -1,361 +1,349 @@
-#!/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 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 {
-        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 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.');
     }
-    catch (error) {
-        throw new Error(`Failed to get GraphQL schema: ${error}`);
+    else if (apolloModule.default && apolloModule.default.HttpLink) {
+        coreExports = apolloModule.default;
+        console.log('[Setup] Apollo exports resolved nested under .default.');
     }
-});
-const toolHandlers = new Map();
-const introspectSchemaHandler = async ({ typeNames, descriptions = true, directives = true }) => {
+    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;
     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);
-                }
-            }
-            else {
-                schema = await introspectEndpoint(env.ENDPOINT, env.HEADERS);
-            }
-            return { content: [{ type: "text", text: schema }] };
-        }
+        // Use the global fetch function
+        response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...headers,
+            },
+            body: JSON.stringify({ query }),
+        });
     }
-    catch (error) {
-        return {
-            isError: true,
-            content: [{ type: "text", text: `Introspection failed: ${error}` }],
-        };
+    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)}...`);
+    }
+    const json = await response.json();
+    if (json.errors) {
+        throw new Error(`GraphQL errors during introspection: ${JSON.stringify(json.errors)}`);
     }
+    return json.data;
 };
-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("e.g., [\"Query\", \"User\"]"),
-    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.",
-                    },
-                ],
-            };
+/**
+ * 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()}`);
+            }
+        });
+        // 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`;
         }
     }
-    catch (error) {
+    // 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}`);
+    }
+    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.');
         return {
-            isError: true,
-            content: [
-                {
-                    type: "text",
-                    text: `Invalid GraphQL query: ${error}`,
-                },
-            ],
+            jsonrpc: '2.0',
+            id: id || null,
+            error: {
+                code: -32000, // Server error
+                message: 'Server failed to initialize Apollo Client.',
+            },
         };
     }
-    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);
+    // --- 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,
+                };
             }
-            else {
-                parsedVariables = 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
+                };
             }
-        }
-        const response = await fetch(env.ENDPOINT, {
-            method: "POST",
-            headers: allHeaders,
-            body: JSON.stringify({
-                query,
-                variables: parsedVariables,
-            }),
-        });
-        if (!response.ok) {
-            const responseText = await response.text();
+            // Fallback for unexpected empty result
             return {
-                isError: true,
-                content: [
-                    {
-                        type: "text",
-                        text: `GraphQL request failed: ${response.statusText}\n${responseText}`,
-                    },
-                ],
+                jsonrpc: '2.0',
+                id: id,
+                error: {
+                    code: -32603, // Internal error
+                    message: 'Error executing GraphQL query: Response was empty.',
+                },
             };
         }
-        const rawData = await response.json();
-        const data = rawData;
-        if (data.errors && data.errors.length > 0) {
+        catch (error) {
+            console.error('GraphQL Execution Error (Catch Block):', error);
             return {
-                isError: true,
-                content: [
-                    {
-                        type: "text",
-                        text: `GraphQL errors: ${JSON.stringify(data.errors, null, 2)}`,
-                    },
-                ],
+                jsonrpc: '2.0',
+                id: id,
+                error: {
+                    code: -32603, // Internal error
+                    message: 'Error executing GraphQL query',
+                    data: error.message,
+                },
             };
         }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(data, null, 2),
-                },
-            ],
-        };
     }
-    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 {
-            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;
-        }
+    // --- 2. Introspect Schema ---
+    if (method === 'introspect-schema') {
         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 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);
             }
-            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;
+            // Check if typeNames are provided for filtered introspection
+            else if (params?.typeNames) {
+                resultText = await introspectTypes(schemaSource, headers, params.typeNames);
+            }
+            // Default: Full introspection
+            else {
+                resultText = await introspectEndpoint(schemaSource, headers);
             }
-            const result = await handler(params);
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
+            // Introspection methods return the schema as a string, which is correct
+            // for the 'text' type output used here.
+            return {
                 jsonrpc: '2.0',
                 id: id,
-                result: result
-            }));
+                result: {
+                    content: [
+                        {
+                            type: 'text',
+                            text: resultText,
+                        },
+                    ],
+                },
+            };
         }
         catch (error) {
-            console.error("HTTP MCP Execution Error:", error);
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
+            console.error('Introspection Error:', error);
+            return {
                 jsonrpc: '2.0',
-                id: request?.id || null,
-                error: { code: -32603, message: 'Internal server error during tool execution.' }
-            }));
+                id: id,
+                error: {
+                    code: -32603, // Internal error
+                    message: 'Error during schema introspection',
+                    data: error.message,
+                },
+            };
         }
-        return;
     }
-    res.writeHead(404, { 'Content-Type': 'text/plain' });
-    res.end('Not Found. Use POST /mcp for JSON-RPC or GET /health.');
-}
-/**
- * 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}`);
-    });
+    // --- 3. Handle unsupported method ---
+    return {
+        jsonrpc: '2.0',
+        id: id || null,
+        error: {
+            code: -32601, // Method not found
+            message: `Method not found: ${method}`,
+        },
+    };
 }
-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);
+// --- 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');
+    }
 });
+// Export the app instance for Vercel
+exports.default = app;

package/package.json

@@ -43,6 +43,8 @@
 	},
 	"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",
@@ -50,5 +52,5 @@
 		"ts-node": "^10.9.2",
 		"typescript": "5.8.3"
 	},
-	"version": "2.3.0"
+	"version": "2.3.1"
 }