@letoribo/mcp-graphql-enhanced 3.1.0 → 3.2.1

package/README.md

@@ -17,13 +17,16 @@ An **enhanced MCP (Model Context Protocol) server for GraphQL** that fixes real-
 
 This server now runs in **dual transport mode**, supporting both the standard **STDIO** communication (used by most MCP clients) and a new **HTTP JSON-RPC** endpoint on port `6274`.
 
-This allows external systems, web applications, and direct `curl` commands to access the server's tools.
+This allows external systems, web applications, and direct `curl` commands to access the server's tools with **live request logging** in your terminal (`[HTTP-RPC]` logs).
 
 | **Endpoint** | **Method** | **Description** |
 | :--- | :--- | :--- |
-| `/mcp` | `POST` | The main JSON-RPC endpoint for tool execution. |
+| `/mcp` | `POST` | The main JSON-RPC 2.0 endpoint for tool execution. |
 | `/health` | `GET` | Simple health check, returns `{ status: 'ok' }`. |
 
+### Automatic Port Selection
+The server defaults to port `6274`. If you encounter an `EADDRINUSE` error, the server will automatically find the next available port. **Check the server logs for the final bound port** (e.g., `[HTTP] Started server on http://localhost:6275`).
+
 ### Resolving Port Conflicts (EADDRINUSE) and Automatic Port Selection
 
 The server defaults to port `6274`. If you encounter an `EADDRINUSE: address already in use :::6274` error (common in local development due to stale processes), the server will automatically find the next available port (up to 10 attempts, not spawning multiple servers).
@@ -62,9 +65,10 @@ npx @modelcontextprotocol/inspector \
 | `HEADERS` | JSON string containing headers for requests | `{}` |
 | `ALLOW_MUTATIONS` | Enable mutation operations (disabled by default) | `false` |
 | `NAME` | Name of the MCP server | `mcp-graphql-enhanced` |
-| `SCHEMA` | Path to a local GraphQL schema file or URL (optional) | - |
+| `SCHEMA` | Path to a local GraphQL schema file or URL | - |
 | `MCP_PORT` | Port for the HTTP/JSON-RPC server. | `6274` |
 | `ENABLE_HTTP` | Enable HTTP transport: `auto` (default), `true`, or `false` | `auto` |
+| `DEBUG` | Set to `mcp:*` for detailed SDK logs | - |
 **Note on `ENABLE_HTTP`:** 
 - `auto` (default): Automatically enables HTTP only when running in MCP Inspector...
 - `true`: Always enable HTTP server

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,CACtC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,mBAiBjC;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,mBAsFpB"}
+{"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,23 +1,20 @@
 "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 },
         body: JSON.stringify({
-            query: (0, graphql_1.getIntrospectionQuery)(), // Removed invalid options
+            query: (0, graphql_1.getIntrospectionQuery)(),
         }),
     });
     if (!response.ok) {
@@ -28,59 +25,26 @@ async function introspectEndpoint(endpoint, headers) {
     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())
-                    // Filter out deprecated fields
                     .filter(([_, field]) => !field.deprecationReason)
                     .map(([fieldName, field]) => [
                     fieldName,
@@ -88,7 +52,6 @@ async function introspectTypes(endpoint, headers = {}, typeNames) {
                         type: field.type.toString(),
                         description: field.description,
                         args: field.args
-                            // Filter out deprecated arguments
                             .filter(arg => !arg.deprecationReason)
                             .map(arg => ({
                             name: arg.name,
@@ -99,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,
@@ -118,26 +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())
-                    // FILTER: Skip deprecated input fields
-                    .filter(([_, field]) => !field.deprecationReason)
-                    .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

@@ -5,25 +5,31 @@ var __importDefault = (this && this.__importDefault) || function (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 mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const language_1 = require("graphql/language");
+const zod_1 = __importDefault(require("zod"));
+// Helper imports
+const deprecation_js_1 = require("./helpers/deprecation.js");
+const introspection_js_1 = require("./helpers/introspection.js");
 const getVersion = () => {
-    const pkg = require("../package.json");
-    return pkg.version;
+    try {
+        const pkg = require("../package.json");
+        return pkg.version;
+    }
+    catch {
+        return "3.2.1";
+    }
 };
-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
+(0, deprecation_js_1.checkDeprecatedArguments)();
+const EnvSchema = zod_1.default.object({
+    NAME: zod_1.default.string().default("mcp-graphql-enhanced"),
+    ENDPOINT: zod_1.default.preprocess((val) => (typeof val === 'string' ? val.trim() : val), zod_1.default.string().url()).default("https://mcp-neo4j-discord.vercel.app/api/graphiql"),
+    ALLOW_MUTATIONS: zod_1.default
         .enum(["true", "false"])
         .transform((value) => value === "true")
         .default("false"),
-    HEADERS: z
+    HEADERS: zod_1.default
         .string()
         .default("{}")
         .transform((val) => {
@@ -34,350 +40,177 @@ const EnvSchema = z.object({
             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),
-    ENABLE_HTTP: z
+    SCHEMA: zod_1.default.string().optional(),
+    MCP_PORT: zod_1.default.preprocess((val) => (val ? parseInt(val) : 6274), zod_1.default.number().int().min(1024).max(65535)).default(6274),
+    ENABLE_HTTP: zod_1.default
         .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 !!(process.env.MCP_INSPECTOR || process.env.INSPECTOR_PORT || process.env.MCP_PORT);
         }
         return value === "true";
     })
-        .default("auto"), // Auto-detect by default
+        .default("auto"),
 });
 const env = EnvSchema.parse(process.env);
-const server = new McpServer({
+const server = new mcp_js_1.McpServer({
     name: env.NAME,
     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;
 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);
+            // Check if it's a URL or local path
+            if (env.SCHEMA.startsWith("http")) {
+                const response = await fetch(env.SCHEMA);
+                sdl = await response.text();
             }
             else {
-                schema = await introspectLocalSchema(env.SCHEMA);
+                sdl = await (0, introspection_js_1.introspectLocalSchema)(env.SCHEMA);
             }
+            cachedSchemaObject = buildASTSchema(gqlParse(sdl));
+            cachedSDL = sdl;
         }
         else {
-            schema = await introspectEndpoint(env.ENDPOINT, env.HEADERS);
+            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;
     }
 }
-server.resource("graphql-schema", new URL(env.ENDPOINT).href, async (uri) => {
-    try {
-        const schema = await getSchema();
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    text: schema,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        throw error;
-    }
-});
+// --- TOOL HANDLERS ---
 const toolHandlers = new Map();
-const introspectSchemaHandler = async ({ typeNames, descriptions = true, directives = true }) => {
-    if (typeNames === null) {
-        typeNames = undefined;
-    }
-    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 }] };
-        }
-    }
-    catch (error) {
-        throw new Error(`Introspection failed: ${error}`); // ✅ Throw instead
-    }
-};
-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);
+// Tool: query-graphql
 const queryGraphqlHandler = async ({ query, variables, headers }) => {
     try {
-        const parsedQuery = parse(query);
+        const parsedQuery = (0, language_1.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 unless you enable them in the configuration. Please use a query operation instead.");
-        }
-    }
-    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 = null;
-        if (variables) {
-            if (typeof variables === 'string') {
-                parsedVariables = JSON.parse(variables);
-            }
-            else {
-                parsedVariables = variables;
-            }
-        }
+        if (isMutation && !env.ALLOW_MUTATIONS)
+            throw new Error("Mutations are not allowed.");
+        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();
-            throw new Error(`GraphQL request failed: ${response.statusText}\n${responseText}`);
-        }
-        const rawData = await response.json();
-        const data = rawData;
-        if (data.errors && data.errors.length > 0) {
-            throw new Error(`GraphQL errors: ${JSON.stringify(data.errors, null, 2)}`);
-        }
+        const data = await response.json();
         return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(data, null, 2),
-                },
-            ],
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
         };
     }
     catch (error) {
-        throw new Error(`Failed to execute GraphQL query: ${error}`);
+        throw new Error(`Execution failed: ${error.message}`);
     }
 };
 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 ...\"}"),
+server.tool("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(),
 }, 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);
-    });
-}
+// Tool: introspect-schema
+const introspectHandler = async ({ typeNames }) => {
+    await getSchema();
+    if (!typeNames || typeNames.length === 0) {
+        const allTypeNames = Object.keys(cachedSchemaObject.getTypeMap()).filter(t => !t.startsWith('__'));
+        return {
+            content: [{ type: "text", text: `Schema is large. Available types: ${allTypeNames.join(", ")}` }]
+        };
+    }
+    const filtered = (0, introspection_js_1.introspectSpecificTypes)(cachedSchemaObject, typeNames);
+    return {
+        content: [{ type: "text", text: JSON.stringify(filtered, null, 2) }]
+    };
+};
+toolHandlers.set("introspect-schema", introspectHandler);
+server.tool("introspect-schema", "Introspect the GraphQL schema with optional type filtering", {
+    typeNames: zod_1.default.array(zod_1.default.string()).optional(),
+}, introspectHandler);
+// --- HTTP SERVER LOGIC ---
 async function handleHttpRequest(req, res) {
     res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Methods', 'POST, GET, 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;
-    }
+    const url = new URL(req.url || '', `http://${req.headers.host}`);
     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;
+        let body = '';
+        req.on('data', chunk => { body += chunk; });
+        req.on('end', async () => {
+            try {
+                const { method, params, id } = JSON.parse(body);
+                console.error(`[HTTP-RPC] Method: ${method} | ID: ${id}`);
+                const handler = toolHandlers.get(method);
+                if (!handler) {
+                    res.writeHead(404);
+                    return res.end(JSON.stringify({ jsonrpc: '2.0', id, error: { code: -32601, message: "Method not found" } }));
+                }
+                const result = await handler(params);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ jsonrpc: '2.0', id, result }));
             }
-            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;
+            catch (e) {
+                console.error(`[HTTP-ERROR] ${e.message}`);
+                res.writeHead(500);
+                res.end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32603, message: "Internal Error" } }));
             }
-            const result = await handler(params);
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                jsonrpc: '2.0',
-                id: id,
-                result: 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.' }
-            }));
-        }
+        });
         return;
     }
-    res.writeHead(404, { 'Content-Type': 'text/plain' });
-    res.end('Not Found. Use POST /mcp for JSON-RPC or GET /health.');
-}
-// 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;
-            }
-            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);
-    });
+    if (url.pathname === '/health') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({ status: "ok", server: env.NAME }));
+    }
+    res.writeHead(404);
+    res.end("Not Found");
 }
+// --- STARTUP ---
 async function main() {
-    // Pre-load schema FIRST (parallel with server setup)
-    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);
-    console.error(`[STDIO] Started GraphQL MCP server ${env.NAME} for endpoint: ${env.ENDPOINT}`);
-    // Only start HTTP if needed
     if (env.ENABLE_HTTP) {
-        try {
-            const port = await startHttpServer(env.MCP_PORT);
-            console.error(`[HTTP] Listening on port ${port} for POST /mcp requests`);
-        }
-        catch (error) {
-            console.error(`[HTTP] Failed to start HTTP server: ${error}`);
-        }
-    }
-    else {
-        console.error(`[HTTP] HTTP transport disabled (ENABLE_HTTP=auto|true to enable)`);
-    }
-    // Wait for schema to finish loading
-    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 {
-        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);
+        const serverHttp = node_http_1.default.createServer(handleHttpRequest);
+        serverHttp.listen(env.MCP_PORT, () => {
+            console.error(`[HTTP] Server started on http://localhost:${env.MCP_PORT}`);
         });
     }
-    else {
-        process.exit(0);
-    }
-});
-main().catch((error) => {
-    console.error(`Fatal error in main(): ${error}`);
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error(`[STDIO] MCP Server "${env.NAME}" v${getVersion()} started`);
+    getSchema().catch(e => console.error(`[SCHEMA] Warning: Preload failed: ${e.message}`));
+}
+process.on('SIGINT', () => process.exit(0));
+process.on('SIGTERM', () => process.exit(0));
+main().catch(error => {
+    console.error(`[FATAL] ${error}`);
     process.exit(1);
 });

package/package.json

@@ -29,7 +29,7 @@
 		"node": ">=18"
 	},
 	"scripts": {
-		"dev": "ts-node src/index.ts",
+		"dev": "tsx --watch src/index.ts",
 		"build": "tsc && chmod +x dist/index.js",
 		"start": "node dist/index.js",
 		"format": "prettier --write ."
@@ -47,7 +47,8 @@
 		"@types/yargs": "17.0.33",
 		"prettier": "^3.6.2",
 		"ts-node": "^10.9.2",
+		"tsx": "^4.21.0",
 		"typescript": "5.8.3"
 	},
-	"version": "3.1.0"
+	"version": "3.2.1"
 }