@letoribo/mcp-graphql-enhanced 3.0.1 → 3.2.0

package/dist/helpers/introspection.d.ts

@@ -1,21 +1,19 @@
+import { GraphQLSchema } from "graphql";
 /**
  * Introspect a GraphQL endpoint and return the schema as the GraphQL SDL
- * @param endpoint - The endpoint to introspect
- * @param headers - Optional headers to include in the request
- * @returns The schema
  */
 export declare function introspectEndpoint(endpoint: string, headers?: Record<string, string>): Promise<string>;
 /**
- * Introspect a GraphQL schema file hosted at a URL and return the schema as the GraphQL SDL
- * @param url - The URL to the schema file
- * @returns The schema
+ * Introspect a local GraphQL schema file
  */
-export declare function introspectSchemaFromUrl(url: string): Promise<string>;
+export declare function introspectLocalSchema(path: string): Promise<string>;
 /**
- * Introspect a local GraphQL schema file and return the schema as the GraphQL SDL
- * @param path - The path to the local schema file
- * @returns The schema
+ * Extract and filter specific types from a schema object.
+ * Prevents "No result received" errors by only sending requested parts of the graph.
+ */
+export declare function introspectSpecificTypes(schema: GraphQLSchema, typeNames: string[]): Record<string, any>;
+/**
+ * Backwards compatibility helper for direct endpoint introspection
  */
-export declare function introspectLocalSchema(path: string): Promise<string>;
 export declare function introspectTypes(endpoint: string, headers: Record<string, string> | undefined, typeNames: string[]): Promise<string>;
 //# sourceMappingURL=introspection.d.ts.map

package/dist/helpers/introspection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"introspection.d.ts","sourceRoot":"","sources":["../../src/helpers/introspection.ts"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACvC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,mBAuBhC;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,GAAG,EAAE,MAAM,mBASxD;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,MAAM,mBAGvD;AAkBD,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAK,EACpC,SAAS,EAAE,MAAM,EAAE,mBA6EpB"}
+{"version":3,"file":"introspection.d.ts","sourceRoot":"","sources":["../../src/helpers/introspection.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,aAAa,EAQd,MAAM,SAAS,CAAC;AAGjB;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,mBAiBjC;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,MAAM,mBAEvD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,uBAmEjF;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAK,EACpC,SAAS,EAAE,MAAM,EAAE,mBAYpB"}

package/dist/helpers/introspection.js

@@ -1,24 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.introspectEndpoint = introspectEndpoint;
-exports.introspectSchemaFromUrl = introspectSchemaFromUrl;
 exports.introspectLocalSchema = introspectLocalSchema;
+exports.introspectSpecificTypes = introspectSpecificTypes;
 exports.introspectTypes = introspectTypes;
 const graphql_1 = require("graphql");
 const promises_1 = require("node:fs/promises");
 /**
  * Introspect a GraphQL endpoint and return the schema as the GraphQL SDL
- * @param endpoint - The endpoint to introspect
- * @param headers - Optional headers to include in the request
- * @returns The schema
  */
 async function introspectEndpoint(endpoint, headers) {
     const response = await fetch(endpoint, {
         method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            ...headers,
-        },
+        headers: { "Content-Type": "application/json", ...headers },
         body: JSON.stringify({
             query: (0, graphql_1.getIntrospectionQuery)(),
         }),
@@ -27,69 +21,39 @@ async function introspectEndpoint(endpoint, headers) {
         throw new Error(`GraphQL request failed: ${response.statusText}`);
     }
     const responseJson = await response.json();
-    // Transform to a schema object
     const schema = (0, graphql_1.buildClientSchema)(responseJson.data);
-    // Print the schema SDL
     return (0, graphql_1.printSchema)(schema);
 }
 /**
- * Introspect a GraphQL schema file hosted at a URL and return the schema as the GraphQL SDL
- * @param url - The URL to the schema file
- * @returns The schema
+ * Introspect a local GraphQL schema file
  */
-async function introspectSchemaFromUrl(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch schema from URL: ${response.statusText}`);
-    }
-    const schema = await response.text();
-    return schema;
+async function introspectLocalSchema(path) {
+    return await (0, promises_1.readFile)(path, "utf8");
 }
 /**
- * Introspect a local GraphQL schema file and return the schema as the GraphQL SDL
- * @param path - The path to the local schema file
- * @returns The schema
+ * Extract and filter specific types from a schema object.
+ * Prevents "No result received" errors by only sending requested parts of the graph.
  */
-async function introspectLocalSchema(path) {
-    const schema = await (0, promises_1.readFile)(path, "utf8");
-    return schema;
-}
-function isObjectLikeType(type) {
-    return 'getFields' in type;
-}
-function isUnionType(type) {
-    return 'getTypes' in type;
-}
-function isEnumType(type) {
-    return 'getValues' in type;
-}
-function isInputObjectType(type) {
-    return 'getFields' in type;
-}
-async function introspectTypes(endpoint, headers = {}, typeNames) {
-    const response = await fetch(endpoint, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", ...headers },
-        body: JSON.stringify({ query: (0, graphql_1.getIntrospectionQuery)() }),
-    });
-    const data = await response.json();
-    const schema = (0, graphql_1.buildClientSchema)(data.data);
+function introspectSpecificTypes(schema, typeNames) {
     const result = {};
     for (const name of typeNames) {
         const type = schema.getType(name);
         if (!type)
             continue;
-        // Handle object/interface types
-        if (isObjectLikeType(type)) {
+        if ((0, graphql_1.isObjectType)(type) || (0, graphql_1.isInterfaceType)(type)) {
             result[name] = {
-                kind: type instanceof graphql_1.GraphQLObjectType ? "OBJECT" : "INTERFACE",
+                kind: (0, graphql_1.isInterfaceType)(type) ? "INTERFACE" : "OBJECT",
                 description: type.description,
-                fields: Object.fromEntries(Object.entries(type.getFields()).map(([fieldName, field]) => [
+                fields: Object.fromEntries(Object.entries(type.getFields())
+                    .filter(([_, field]) => !field.deprecationReason)
+                    .map(([fieldName, field]) => [
                     fieldName,
                     {
                         type: field.type.toString(),
                         description: field.description,
-                        args: field.args.map(arg => ({
+                        args: field.args
+                            .filter(arg => !arg.deprecationReason)
+                            .map(arg => ({
                             name: arg.name,
                             type: arg.type.toString(),
                             description: arg.description,
@@ -98,16 +62,19 @@ async function introspectTypes(endpoint, headers = {}, typeNames) {
                 ]))
             };
         }
-        // Handle union types
-        else if (isUnionType(type)) {
+        else if ((0, graphql_1.isInputObjectType)(type)) {
             result[name] = {
-                kind: "UNION",
+                kind: "INPUT_OBJECT",
                 description: type.description,
-                possibleTypes: type.getTypes().map(t => t.name)
+                fields: Object.fromEntries(Object.entries(type.getFields())
+                    .filter(([_, field]) => !field.deprecationReason)
+                    .map(([fieldName, field]) => [
+                    fieldName,
+                    { type: field.type.toString(), description: field.description }
+                ]))
             };
         }
-        // Handle enums
-        else if (isEnumType(type)) {
+        else if ((0, graphql_1.isEnumType)(type)) {
             result[name] = {
                 kind: "ENUM",
                 description: type.description,
@@ -117,23 +84,33 @@ async function introspectTypes(endpoint, headers = {}, typeNames) {
                 }))
             };
         }
-        // Handle scalars and input objects
-        else if (isInputObjectType(type)) {
+        else if ((0, graphql_1.isUnionType)(type)) {
             result[name] = {
-                kind: "INPUT_OBJECT",
+                kind: "UNION",
                 description: type.description,
-                fields: Object.fromEntries(Object.entries(type.getFields()).map(([fieldName, field]) => [
-                    fieldName,
-                    { type: field.type.toString(), description: field.description }
-                ]))
+                possibleTypes: type.getTypes().map(t => t.name)
             };
         }
-        else if (type instanceof graphql_1.GraphQLScalarType) {
+        else if ((0, graphql_1.isScalarType)(type)) {
             result[name] = {
                 kind: "SCALAR",
                 description: type.description
             };
         }
     }
-    return JSON.stringify(result, null, 2);
+    return result;
+}
+/**
+ * Backwards compatibility helper for direct endpoint introspection
+ */
+async function introspectTypes(endpoint, headers = {}, typeNames) {
+    const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...headers },
+        body: JSON.stringify({ query: (0, graphql_1.getIntrospectionQuery)() }),
+    });
+    const data = await response.json();
+    const schema = (0, graphql_1.buildClientSchema)(data.data);
+    const result = introspectSpecificTypes(schema, typeNames);
+    return JSON.stringify(result);
 }

package/dist/index.js

@@ -10,7 +10,7 @@ const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio
 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 { introspectEndpoint, introspectLocalSchema, introspectSchemaFromUrl, introspectSpecificTypes, } = require("./helpers/introspection.js");
 const getVersion = () => {
     const pkg = require("../package.json");
     return pkg.version;
@@ -40,13 +40,11 @@ const EnvSchema = z.object({
         .enum(["true", "false", "auto"])
         .transform((value) => {
         if (value === "auto") {
-            // Auto-detect: enable HTTP if running in MCP Inspector
-            // Inspector sets specific environment variables
             return !!(process.env.MCP_INSPECTOR || process.env.INSPECTOR_PORT);
         }
         return value === "true";
     })
-        .default("auto"), // Auto-detect by default
+        .default("auto"),
 });
 const env = EnvSchema.parse(process.env);
 const server = new McpServer({
@@ -54,203 +52,178 @@ const server = new McpServer({
     version: getVersion(),
     description: `GraphQL MCP server for ${env.ENDPOINT}`,
 });
-// Cache schema to avoid repeated introspection
-let cachedSchema = null;
+// --- CACHE STATE ---
+let cachedSDL = null;
+let cachedSchemaObject = null;
 let schemaLoadError = null;
+/**
+ * Loads the schema into memory.
+ * Populates both cachedSDL (string) and cachedSchemaObject (GraphQLSchema object).
+ */
 async function getSchema() {
-    // Return cached schema if available
-    if (cachedSchema) {
-        return cachedSchema;
-    }
-    // Return cached error if schema failed to load
-    if (schemaLoadError) {
+    if (cachedSDL)
+        return cachedSDL;
+    if (schemaLoadError)
         throw schemaLoadError;
-    }
     try {
-        let schema;
+        const { buildClientSchema, getIntrospectionQuery, printSchema, buildASTSchema, parse: gqlParse } = require("graphql");
+        let sdl;
         if (env.SCHEMA) {
-            if (env.SCHEMA.startsWith("http://") ||
-                env.SCHEMA.startsWith("https://")) {
-                schema = await introspectSchemaFromUrl(env.SCHEMA);
+            if (env.SCHEMA.startsWith("http")) {
+                sdl = await introspectSchemaFromUrl(env.SCHEMA);
             }
             else {
-                schema = await introspectLocalSchema(env.SCHEMA);
+                sdl = await introspectLocalSchema(env.SCHEMA);
             }
+            cachedSchemaObject = buildASTSchema(gqlParse(sdl));
+            cachedSDL = sdl;
         }
         else {
-            schema = await introspectEndpoint(env.ENDPOINT, env.HEADERS);
+            // Live Introspection
+            const response = await fetch(env.ENDPOINT, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", ...env.HEADERS },
+                body: JSON.stringify({ query: getIntrospectionQuery() }),
+            });
+            if (!response.ok)
+                throw new Error(`Fetch failed: ${response.statusText}`);
+            const result = await response.json();
+            cachedSchemaObject = buildClientSchema(result.data);
+            cachedSDL = printSchema(cachedSchemaObject);
         }
-        // Cache the schema
-        cachedSchema = schema;
         console.error(`[SCHEMA] Successfully loaded and cached GraphQL schema`);
-        return schema;
+        return cachedSDL;
     }
     catch (error) {
-        schemaLoadError = error;
-        throw new Error(`Failed to get GraphQL schema: ${error}`);
+        schemaLoadError = error instanceof Error ? error : new Error(String(error));
+        throw schemaLoadError;
     }
 }
+// --- RESOURCES ---
 server.resource("graphql-schema", new URL(env.ENDPOINT).href, async (uri) => {
     try {
-        const schema = await getSchema();
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    text: schema,
-                },
-            ],
-        };
+        const sdl = await getSchema();
+        return { contents: [{ uri: uri.href, text: sdl }] };
     }
     catch (error) {
         throw error;
     }
 });
+// --- TOOL HANDLERS ---
 const toolHandlers = new Map();
-const introspectSchemaHandler = async ({ typeNames, descriptions = true, directives = true }) => {
-    if (typeNames === null) {
-        typeNames = undefined;
-    }
+const introspectSchemaHandler = async ({ typeNames }) => {
     try {
-        if (typeNames && typeNames.length > 0) {
-            const filtered = await introspectTypes(env.ENDPOINT, env.HEADERS, typeNames);
-            return { content: [{ type: "text", text: filtered }] };
-        }
-        else {
-            const schema = await getSchema();
-            return { content: [{ type: "text", text: schema }] };
+        // Ensure cache is populated
+        await getSchema();
+        // Safety: If no specific types requested, return the 'Map' of types to prevent bridge crash
+        if (!typeNames || typeNames.length === 0) {
+            const allTypeNames = Object.keys(cachedSchemaObject.getTypeMap())
+                .filter(t => !t.startsWith('__'));
+            return {
+                content: [{
+                        type: "text",
+                        text: `Schema is large. Please request specific types for full details.\n\nAvailable types: ${allTypeNames.join(", ")}`
+                    }]
+            };
         }
-    }
-    catch (error) {
+        // Use the new filtering logic from helpers/introspection.js
+        const filteredResult = introspectSpecificTypes(cachedSchemaObject, typeNames);
         return {
-            isError: true,
-            content: [{ type: "text", text: `Introspection failed: ${error}` }],
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(filteredResult, null, 2)
+                }]
         };
     }
+    catch (error) {
+        throw new Error(`Introspection failed: ${error.message}`);
+    }
 };
 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 }) => {
+    typeNames: z.array(z.string()).optional().describe("A list of specific type names to filter (e.g. ['User', 'Post'])."),
+}, async ({ typeNames }) => {
     try {
-        const parsedQuery = parse(query);
-        const isMutation = parsedQuery.definitions.some((def) => def.kind === "OperationDefinition" && def.operation === "mutation");
-        if (isMutation && !env.ALLOW_MUTATIONS) {
+        console.error(`[TOOL] Introspect called with types: ${JSON.stringify(typeNames || "NONE")}`);
+        // 1. Ensure the schema is loaded into the cache
+        await getSchema();
+        // 2. THE GATEKEEPER: If no types requested, send ONLY names.
+        if (!typeNames || typeNames.length === 0) {
+            const allTypeNames = Object.keys(cachedSchemaObject.getTypeMap())
+                .filter(t => !t.startsWith('__'));
+            console.error(`[TOOL] Sending summary list of ${allTypeNames.length} types.`);
             return {
-                isError: true,
-                content: [
-                    {
+                content: [{
                         type: "text",
-                        text: "Mutations are not allowed unless you enable them in the configuration. Please use a query operation instead.",
-                    },
-                ],
+                        text: `Schema is large. Please request specific types for details.\n\nAvailable types: ${allTypeNames.join(", ")}`
+                    }]
             };
         }
-    }
-    catch (error) {
+        // 3. DRILL DOWN: If Claude asks for specific types, use the helper.
+        console.error(`[TOOL] Filtering for: ${typeNames.join(", ")}`);
+        const filteredResult = introspectSpecificTypes(cachedSchemaObject, typeNames);
         return {
-            isError: true,
-            content: [
-                {
+            content: [{
                     type: "text",
-                    text: `Invalid GraphQL query: ${error}`,
-                },
-            ],
+                    text: JSON.stringify(filteredResult, null, 2)
+                }]
         };
     }
+    catch (error) {
+        console.error(`[TOOL ERROR] ${error.message}`);
+        throw new Error(`Introspection failed: ${error.message}`);
+    }
+});
+const queryGraphqlHandler = async ({ query, variables, headers }) => {
     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);
-            }
-            else {
-                parsedVariables = variables;
-            }
+        const parsedQuery = parse(query);
+        const isMutation = parsedQuery.definitions.some((def) => def.kind === "OperationDefinition" && def.operation === "mutation");
+        if (isMutation && !env.ALLOW_MUTATIONS) {
+            throw new Error("Mutations are not allowed. Enable ALLOW_MUTATIONS in config.");
         }
+    }
+    catch (error) {
+        throw new Error(`Invalid GraphQL query: ${error}`);
+    }
+    try {
+        const toolHeaders = headers ? JSON.parse(headers) : {};
+        const allHeaders = { "Content-Type": "application/json", ...env.HEADERS, ...toolHeaders };
+        let parsedVariables = variables;
+        if (typeof variables === 'string')
+            parsedVariables = JSON.parse(variables);
         const response = await fetch(env.ENDPOINT, {
             method: "POST",
             headers: allHeaders,
-            body: JSON.stringify({
-                query,
-                variables: parsedVariables,
-            }),
+            body: JSON.stringify({ query, variables: parsedVariables }),
         });
         if (!response.ok) {
             const responseText = await response.text();
-            return {
-                isError: true,
-                content: [
-                    {
-                        type: "text",
-                        text: `GraphQL request failed: ${response.statusText}\n${responseText}`,
-                    },
-                ],
-            };
+            throw new Error(`GraphQL request failed: ${response.statusText}\n${responseText}`);
         }
-        const rawData = await response.json();
-        const data = rawData;
+        const data = await response.json();
         if (data.errors && data.errors.length > 0) {
-            return {
-                isError: true,
-                content: [
-                    {
-                        type: "text",
-                        text: `GraphQL errors: ${JSON.stringify(data.errors, null, 2)}`,
-                    },
-                ],
-            };
+            throw new Error(`GraphQL errors: ${JSON.stringify(data.errors, null, 2)}`);
         }
         return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(data, null, 2),
-                },
-            ],
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
         };
     }
     catch (error) {
-        return {
-            isError: true,
-            content: [
-                {
-                    type: "text",
-                    text: `Failed to execute GraphQL query: ${error}`,
-                },
-            ],
-        };
+        throw new Error(`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).", {
+server.tool("query-graphql", "Query a GraphQL endpoint with the given query and variables.", {
     query: z.string(),
     variables: z.string().optional(),
-    headers: z
-        .string()
-        .optional()
-        .describe("Optional JSON string of headers to include, e.g., {\"Authorization\": \"Bearer ...\"}"),
+    headers: z.string().optional().describe("Optional JSON string of headers"),
 }, queryGraphqlHandler);
+// --- HTTP SERVER LOGIC ---
 function readBody(req) {
     return new Promise((resolve, reject) => {
         let body = '';
-        req.on('data', (chunk) => {
-            body += chunk.toString();
-        });
-        req.on('end', () => {
-            resolve(body);
-        });
+        req.on('data', chunk => body += chunk.toString());
+        req.on('end', () => resolve(body));
         req.on('error', reject);
     });
 }
@@ -270,156 +243,77 @@ async function handleHttpRequest(req, res) {
         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;
-        }
-        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;
-            }
+            const rawBody = await readBody(req);
+            const { method, params, id } = JSON.parse(rawBody);
             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}` }
-                }));
+                res.writeHead(404);
+                res.end(JSON.stringify({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } }));
                 return;
             }
             const result = await handler(params);
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                jsonrpc: '2.0',
-                id: id,
-                result: result
-            }));
+            res.end(JSON.stringify({ jsonrpc: '2.0', id, result }));
         }
         catch (error) {
-            console.error("HTTP MCP Execution Error:", error);
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                jsonrpc: '2.0',
-                id: request?.id || null,
-                error: { code: -32603, message: 'Internal server error during tool execution.' }
-            }));
+            res.writeHead(500);
+            res.end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32603, message: 'Internal error' } }));
         }
         return;
     }
-    res.writeHead(404, { 'Content-Type': 'text/plain' });
-    res.end('Not Found. Use POST /mcp for JSON-RPC or GET /health.');
+    res.writeHead(404);
+    res.end('Not Found');
 }
-// Single HTTP server instance
 let httpServer = null;
-/**
- * Tries to listen on a given port with a single retry attempt.
- * Returns the port it successfully bound to.
- */
 async function startHttpServer(initialPort) {
     return new Promise((resolve, reject) => {
-        let currentPort = initialPort;
-        const maxAttempts = 10;
-        let attempts = 0;
-        function tryPort(port) {
-            if (attempts >= maxAttempts) {
-                reject(new Error(`Failed to bind HTTP server after ${maxAttempts} attempts`));
-                return;
-            }
-            if (port > 65535) {
-                reject(new Error(`Exceeded maximum port number (65535)`));
-                return;
+        let port = initialPort;
+        const server = node_http_1.default.createServer(handleHttpRequest);
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                server.close();
+                resolve(startHttpServer(port + 1));
             }
-            attempts++;
-            const server = node_http_1.default.createServer(handleHttpRequest);
-            server.once('error', (err) => {
-                if (err.code === 'EADDRINUSE') {
-                    console.error(`[HTTP] Port ${port} in use, trying ${port + 1}...`);
-                    server.close();
-                    tryPort(port + 1);
-                }
-                else {
-                    reject(err);
-                }
-            });
-            server.listen(port, () => {
-                httpServer = server;
-                console.error(`[HTTP] Server started on http://localhost:${port}`);
-                resolve(port);
-            });
-        }
-        tryPort(currentPort);
+            else
+                reject(err);
+        });
+        server.listen(port, () => {
+            httpServer = server;
+            resolve(port);
+        });
     });
 }
+// --- STARTUP ---
 async function main() {
+    console.error(`[SCHEMA] Pre-loading GraphQL schema...`);
+    const schemaPromise = getSchema().catch(error => {
+        console.error(`[SCHEMA] Warning: Failed to pre-load schema: ${error}`);
+    });
     const stdioTransport = new StdioServerTransport();
     await server.connect(stdioTransport);
-    // Only start HTTP server if explicitly enabled
+    console.error(`[STDIO] Started GraphQL MCP server ${env.NAME}`);
     if (env.ENABLE_HTTP) {
         try {
             const port = await startHttpServer(env.MCP_PORT);
-            console.error(`[HTTP] Listening on port ${port} for POST /mcp requests`);
+            console.error(`[HTTP] Server started on http://localhost:${port}`);
         }
         catch (error) {
-            console.error(`[HTTP] Failed to start HTTP server: ${error}`);
-            // Don't exit - STDIO transport is more important
+            console.error(`[HTTP] Failed to start: ${error}`);
         }
     }
-    else {
-        console.error(`[HTTP] HTTP transport disabled (ENABLE_HTTP=auto|true to enable)`);
-    }
-    try {
-        await getSchema();
-    }
-    catch (error) {
-        console.error(`[SCHEMA] Warning: Failed to pre-load schema: ${error}`);
-    }
+    await schemaPromise;
 }
-// Graceful shutdown
-process.on('SIGINT', () => {
-    console.error('\n[SHUTDOWN] Received SIGINT, closing server...');
-    if (httpServer) {
-        httpServer.close(() => {
-            console.error('[SHUTDOWN] HTTP server closed');
-            process.exit(0);
-        });
-    }
-    else {
+// Graceful exit
+const shutdown = () => {
+    if (httpServer)
+        httpServer.close(() => process.exit(0));
+    else
         process.exit(0);
-    }
-});
-process.on('SIGTERM', () => {
-    console.error('\n[SHUTDOWN] Received SIGTERM, closing server...');
-    if (httpServer) {
-        httpServer.close(() => {
-            console.error('[SHUTDOWN] HTTP server closed');
-            process.exit(0);
-        });
-    }
-    else {
-        process.exit(0);
-    }
-});
-main().catch((error) => {
-    console.error(`Fatal error in main(): ${error}`);
+};
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+main().catch(error => {
+    console.error(`Fatal error: ${error}`);
     process.exit(1);
 });

package/package.json

@@ -49,5 +49,5 @@
 		"ts-node": "^10.9.2",
 		"typescript": "5.8.3"
 	},
-	"version": "3.0.1"
+	"version": "3.2.0"
 }