@letoribo/mcp-graphql-enhanced 3.9.0 → 3.9.1

package/README.md

@@ -23,15 +23,14 @@ This is the best place to share your feedback, report issues, or suggest new "en
 * ✅ **Dynamic Schema Evolution** — Smart diagnostics and gap analysis for servers that regenerate GraphQL types on-the-fly (like Neo4j).
 * ✅ **Deep Observability** — Automatic Cypher extraction and cleaning from GraphQL extensions.
 
-## 🚀 Multi-Endpoint Broadcast (Experimental in v3.9.0+)
-Starting from **v3.9.0**, the server supports querying multiple GraphQL endpoints simultaneously. This was originally designed to synchronize mutations across different environments (e.g., Node.js and Python backends), but it opens up powerful possibilities for data aggregation.
+## 🚀 Federated Multi-Node Architecture (v3.9.1+)
+The server operates as a Federated GraphQL Gateway, merging independent nodes into a unified system.
 
 *   **Zero Breaking Changes**: If you provide a single URL in `ENDPOINT`, the server behaves exactly as before.
-*   **Smart Aggregation**: When multiple comma-separated URLs are provided, the server broadcasts the query to all of them and **merges the resulting arrays**.
+*   **Federated Introspection**: Scans all endpoints simultaneously to build a global capability map.
+*   **Smart Aggregation**: When multiple comma-separated URLs are provided, the server broadcasts queries and merges results using universal deep deduplication (object-level).
+*   **Conflict Handling**: Identifies structural differences in identical Type names across nodes and exposes them uniquely.
 *   **Bypass Free Tier Limits**: Perfect for users of "Free Tier" cloud databases (like Neo4j Aura). You can split your data across multiple free instances and use this bridge to query them as a **single unified graph**, effectively bypassing entity count limitations.
-*   **Deduplication**: The bridge automatically removes duplicate objects based on their unique fields to keep the AI's context window clean.
-
-> **⚠️ Use at your own risk:** This feature assumes all endpoints share the same (or very similar) GraphQL schema. The introspection is performed against the **first** endpoint in the list.
 
 #### 💡 Use Case: Bridging WSL and Windows (PowerShell)
 A common challenge for Windows developers is the network isolation between the Windows Subsystem for Linux (WSL) and the host OS. This feature allows you to bridge these two worlds into a "Unified Nervous System".  

package/dist/index.js

@@ -30,15 +30,13 @@ const getVersion = () => {
 };
 (0, deprecation_js_1.checkDeprecatedArguments)();
 /**
- * Environment configuration schema
+ * Environment configuration schema - Strict validation
  */
 const EnvSchema = zod_1.default.object({
     NAME: zod_1.default.string().default("mcp-graphql-enhanced"),
     ENDPOINT: zod_1.default.preprocess((val) => {
-        if (typeof val === 'string') {
-            // Support for multiple endpoints via comma-separated string
+        if (typeof val === 'string')
             return val.trim();
-        }
         return val;
     }, zod_1.default.string().min(1)).default("https://mcp-neo4j-discord.vercel.app/api/graphiql"),
     ALLOW_MUTATIONS: zod_1.default
@@ -69,57 +67,52 @@ const EnvSchema = zod_1.default.object({
         .default("auto"),
 });
 const env = EnvSchema.parse(process.env);
+/**
+ * Initialize MCP Server with full capabilities
+ */
 const server = new mcp_js_1.McpServer({
     name: env.NAME,
     version: getVersion(),
-    description: "Unified GraphQL-to-MCP bridge with dynamic schema support."
+    description: "Federated GraphQL-to-MCP bridge with broadcast introspection and full type visibility."
 }, {
     capabilities: {
         prompts: {},
         tools: {}
     }
 });
-// --- CACHE STATE ---
+// --- GLOBAL STATE MANAGEMENT ---
 let cachedSDL = null;
 let cachedSchemaObject = null;
+let cachedSchemas = [];
 let schemaLoadError = null;
 let isUpdating = false;
 let updatePromise = null;
-let lastKnownTypeCount = 0;
 /**
- * Smart Hybrid Schema Fetcher
- * @param force If true, blocks and waits for the new schema evolution.
- * If false, returns cache immediately and updates in background.
+ * Schema Fetcher with dependency tracking
  */
 async function getSchema(force = false, requestedTypes) {
-    // 1. Hook into existing update if in progress
     if (isUpdating && updatePromise) {
         if (force || !cachedSDL)
             return await updatePromise;
         return cachedSDL;
     }
-    // 2. Return cache if valid and not forcing
     if (cachedSDL && !force) {
-        // Validation check: ensure requested types exist in current cache
-        if (requestedTypes && cachedSchemaObject) {
-            const typeMap = cachedSchemaObject.getTypeMap();
-            const missing = requestedTypes.filter(t => !typeMap[t]);
-            if (missing.length > 0) {
-                // Force a refresh if requested types are missing
+        if (requestedTypes && cachedSchemas.length > 0) {
+            const allTypes = new Set(cachedSchemas.flatMap(s => Object.keys(s.getTypeMap())));
+            const missing = requestedTypes.filter(t => !allTypes.has(t));
+            if (missing.length > 0)
                 return await (updatePromise = performUpdate(true));
-            }
         }
-        return cachedSDL;
+        return cachedSchemaObject;
     }
     if (force)
         schemaLoadError = null;
     if (schemaLoadError)
         throw schemaLoadError;
-    // 3. Trigger update
     updatePromise = performUpdate(force);
     try {
         if (force || !cachedSDL) {
-            await updatePromise; // Wait for update to complete
+            await updatePromise;
             return cachedSchemaObject;
         }
         return cachedSchemaObject;
@@ -129,354 +122,246 @@ async function getSchema(force = false, requestedTypes) {
     }
 }
 /**
- * Internal logic for schema introspection and building.
- * Optimized for Multi-Endpoint Broadcast: Uses the first available URL for discovery.
+ * Federated Update: Orchestrates introspection across all endpoints
  */
 async function performUpdate(force) {
     isUpdating = true;
     const startTime = Date.now();
     try {
-        const { buildClientSchema, getIntrospectionQuery, printSchema, buildASTSchema, parse: gqlParse, isObjectType } = require("graphql");
-        let tempSchema;
-        // --- FETCHING LOGIC ---
-        if (env.SCHEMA) {
-            let sdl;
-            if (env.SCHEMA.startsWith("http")) {
-                // Remote SDL File
-                const response = await fetch(env.SCHEMA);
-                if (!response.ok)
-                    throw new Error(`Remote_SDL_Fetch_Failed: ${response.statusText}`);
-                sdl = await response.text();
-            }
-            else {
-                // Local SDL File via helper
-                sdl = await (0, introspection_js_1.introspectLocalSchema)(env.SCHEMA);
-            }
-            tempSchema = buildASTSchema(gqlParse(sdl));
-        }
-        else {
-            // --- BROADCAST ADAPTATION ---
-            // Extract the primary endpoint for introspection
-            const endpoints = env.ENDPOINT.split(',').map(url => url.trim());
-            const primaryEndpoint = endpoints[0];
-            // Execute Introspection against the primary target
-            const response = await fetch(primaryEndpoint, {
+        const endpoints = env.ENDPOINT.split(',').map(url => url.trim());
+        console.error(`[SYNC] Initializing broadcast to ${endpoints.length} nodes...`);
+        const results = await Promise.allSettled(endpoints.map(async (url) => {
+            const response = await fetch(url, {
                 method: "POST",
                 headers: { "Content-Type": "application/json", ...env.HEADERS },
-                body: JSON.stringify({ query: getIntrospectionQuery() }),
+                body: JSON.stringify({ query: (0, graphql_1.getIntrospectionQuery)() }),
+                signal: AbortSignal.timeout(10000)
             });
             if (!response.ok)
-                throw new Error(`HTTP_${response.status} at ${primaryEndpoint}: ${response.statusText}`);
+                throw new Error(`HTTP Error ${response.status}`);
             const result = await response.json();
             if (!result.data)
-                throw new Error("Invalid GraphQL response: Missing 'data' field.");
-            tempSchema = buildClientSchema(result.data);
+                throw new Error("Empty introspection data");
+            const schema = (0, graphql_1.buildClientSchema)(result.data);
+            schema._originUrl = url;
+            return { url, schema };
+        }));
+        const successful = results
+            .filter((r) => r.status === 'fulfilled')
+            .map(r => r.value);
+        const failures = results
+            .filter((r) => r.status === 'rejected')
+            .map(r => r.reason.message);
+        if (successful.length === 0) {
+            throw new Error(`Federation failed. All nodes unreachable: ${failures.join(', ')}`);
         }
-        // --- UNIFIED STRUCTURAL ANALYSIS ---
-        const typeMap = tempSchema.getTypeMap();
-        // Filter domain types while ignoring internal system scalars and types
-        const businessTypes = Object.keys(typeMap).filter(typeName => {
-            const type = typeMap[typeName];
-            return (!typeName.startsWith('__') &&
-                !['Query', 'Mutation', 'Subscription'].includes(typeName) &&
-                !['String', 'Int', 'Float', 'Boolean', 'ID', 'BigInt', 'DateTime'].includes(typeName) &&
-                isObjectType(type));
+        // Update cache with all discovered schemas
+        cachedSchemas = successful.map(s => s.schema);
+        cachedSchemaObject = cachedSchemas[0]; // Baseline schema
+        cachedSDL = (0, graphql_1.printSchema)(cachedSchemaObject);
+        // Generate Node Manifest for AI reasoning (Full data, no slices)
+        global.nodeManifest = successful.map(node => {
+            const typeMap = node.schema.getTypeMap();
+            const domainTypes = Object.keys(typeMap).filter(name => {
+                const type = typeMap[name];
+                return !name.startsWith('__') && !(0, graphql_1.isScalarType)(type);
+            });
+            return {
+                endpoint: node.url,
+                availableMutations: Object.keys(node.schema.getMutationType()?.getFields() || {}),
+                domainEntities: domainTypes
+            };
         });
-        lastKnownTypeCount = businessTypes.length;
-        const currentSDL = printSchema(tempSchema);
-        // Always update the live object upon successful build
-        cachedSchemaObject = tempSchema;
-        if (currentSDL !== cachedSDL) {
-            cachedSDL = currentSDL;
-            const duration = ((Date.now() - startTime) / 1000).toFixed(2);
-            const endpointLabel = env.SCHEMA ? 'Local/Remote SDL' : `Live Broadcast Node (${env.ENDPOINT.split(',').length} targets)`;
-            return [
-                `✨ SCHEMA EVOLVED (${duration}s)`,
-                `📊 Source: ${endpointLabel}`,
-                `🧬 Labels: ${businessTypes.join(', ') || 'None'}`,
-                `---`,
-                `The bridge has updated the graph model. New types are now queryable.`
-            ].join('\n');
-        }
-        else {
-            return `✅ Status: Schema stable (${lastKnownTypeCount} labels).`;
-        }
+        const uniqueTypeCount = new Set(cachedSchemas.flatMap(s => Object.keys(s.getTypeMap()))).size;
+        const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+        return `✅ FEDERATION SYNCED: ${successful.length} active nodes, ${uniqueTypeCount} unique types discovered in ${duration}s.`;
     }
     catch (error) {
-        return [
-            `❌ SCHEMA SYNC FAILED`,
-            `🔍 Reason: ${error.message}`,
-            `🛠️ Action: Verify your connection and retry.`
-        ].join('\n');
+        console.error(`[CRITICAL] Sync failure: ${error.message}`);
+        schemaLoadError = error;
+        return `❌ SYNC ERROR: ${error.message}`;
     }
     finally {
         isUpdating = false;
         updatePromise = null;
     }
 }
-// --- TOOL REGISTRY ---
+// --- TOOLS IMPLEMENTATION ---
 const toolHandlers = new Map();
 const registeredToolsMetadata = [];
-/**
- * History buffer for the last 5 operations to support debugging and visualization.
- */
-let executionLogs = [];
 /**
  * Tool: query-graphql
- * Handles query broadcast and execution across multiple endpoints.
+ * Broadcasts queries to all nodes and merges results with universal deduplication.
  */
 const queryGraphqlHandler = async ({ query, variables, headers }) => {
     try {
         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.");
+        const hasMutation = parsedQuery.definitions.some((def) => def.kind === "OperationDefinition" && def.operation === "mutation");
+        if (hasMutation && !env.ALLOW_MUTATIONS) {
+            throw new Error("Mutation execution is blocked by ALLOW_MUTATIONS=false.");
         }
-        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);
-        // Split multiple endpoints for broadcast
+        const runtimeHeaders = headers ? JSON.parse(headers) : {};
+        const fetchHeaders = { "Content-Type": "application/json", ...env.HEADERS, ...runtimeHeaders };
+        const fetchVariables = variables ? (typeof variables === 'string' ? JSON.parse(variables) : variables) : undefined;
         const endpoints = env.ENDPOINT.split(',').map(url => url.trim());
-        // Execute parallel requests to all targets
-        const settleResults = await Promise.allSettled(endpoints.map(async (url) => {
-            console.error(`[QUERY] Sending to ${url}`);
+        const executeResults = await Promise.allSettled(endpoints.map(async (url) => {
             const response = await fetch(url, {
                 method: "POST",
-                headers: allHeaders,
-                body: JSON.stringify({ query, variables: parsedVariables }),
-                signal: AbortSignal.timeout(5000) // 5s timeout protection
+                headers: fetchHeaders,
+                body: JSON.stringify({ query, variables: fetchVariables }),
+                signal: AbortSignal.timeout(15000)
             });
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status} from ${url}`);
-            }
-            return {
-                url,
-                data: await response.json()
-            };
+            if (!response.ok)
+                throw new Error(`Node ${url} returned ${response.status}`);
+            return { url, data: await response.json() };
         }));
-        const successfulResponses = settleResults
+        const successes = executeResults
             .filter((r) => r.status === 'fulfilled')
             .map(r => r.value);
-        const failedResponses = settleResults
-            .filter((r) => r.status === 'rejected')
-            .map(r => r.reason.message || r.reason);
-        if (successfulResponses.length === 0) {
-            throw new Error(`All endpoints failed: ${failedResponses.join('; ')}`);
-        }
-        const aggregatedResult = {};
-        successfulResponses.forEach((response) => {
-            const data = response.data.data;
-            if (data && data.patterns) {
-                console.error(`[DEBUG] Received ${data.patterns.length} patterns from ${response.url}`);
-            }
-            if (!data)
+        if (successes.length === 0)
+            throw new Error("Execution failed on all available nodes.");
+        // Aggregate and Deduplicate
+        const mergedData = {};
+        successes.forEach((resp) => {
+            const nodeData = resp.data.data;
+            if (!nodeData)
                 return;
-            Object.keys(data).forEach(key => {
-                if (Array.isArray(data[key])) {
-                    // Merge arrays from different sources
-                    aggregatedResult[key] = [...(aggregatedResult[key] || []), ...data[key]];
+            Object.keys(nodeData).forEach(key => {
+                if (Array.isArray(nodeData[key])) {
+                    const existing = mergedData[key] || [];
+                    const combined = [...existing, ...nodeData[key]];
+                    // Universal object-level deduplication
+                    mergedData[key] = Array.from(new Set(combined.map(v => JSON.stringify(v))))
+                        .map(s => JSON.parse(s));
                 }
-                else if (typeof data[key] === 'object' && data[key] !== null) {
-                    // Merge objects (e.g. metadata)
-                    aggregatedResult[key] = { ...(aggregatedResult[key] || {}), ...data[key] };
+                else if (typeof nodeData[key] === 'object' && nodeData[key] !== null) {
+                    mergedData[key] = { ...(mergedData[key] || {}), ...nodeData[key] };
                 }
                 else {
-                    // Use last value for primitives
-                    aggregatedResult[key] = data[key];
+                    mergedData[key] = nodeData[key];
                 }
             });
         });
-        // 2. Deduplication (Removes duplicates by 'sticking' field)
-        if (aggregatedResult.patterns) {
-            const unique = new Map();
-            aggregatedResult.patterns.forEach((p) => unique.set(p.sticking, p));
-            aggregatedResult.patterns = Array.from(unique.values());
-        }
-        // 3. Extract Cypher queries from extensions
-        const allCypher = successfulResponses.flatMap(r => r.data.extensions?.cypher || []);
-        const cleanCypher = allCypher.map((c) => c.replace(/^CYPHER: /, '').replace(/^CYPHER 5\n/, '').replace(/\nPARAMS: \{\}$/, ''));
-        // 4. Final response for the AI agent
-        const responseForClaude = {
-            status: {
-                total: endpoints.length,
-                success: successfulResponses.length,
-                failed: failedResponses.length
-            },
-            result: aggregatedResult,
-            ...(cleanCypher.length > 0 ? { cypher: Array.from(new Set(cleanCypher)) } : {}),
-            ...(failedResponses.length > 0 ? { warnings: failedResponses } : {})
-        };
+        // Restore Cypher extraction logic
+        const cypherLogs = successes.flatMap(r => r.data.extensions?.cypher || []);
+        const cleanCypher = cypherLogs.map((c) => c.replace(/^CYPHER: /, '').replace(/^CYPHER 5\n/, '').replace(/\nPARAMS: \{\}$/, ''));
         return {
             content: [{
                     type: "text",
-                    text: JSON.stringify(responseForClaude, null, 2)
+                    text: JSON.stringify({
+                        meta: { nodes_queried: endpoints.length, nodes_responding: successes.length },
+                        data: mergedData,
+                        ...(cleanCypher.length > 0 ? { cypher_execution_plan: cleanCypher } : {})
+                    }, null, 2)
                 }]
         };
     }
     catch (error) {
-        throw new Error(`Execution failed: ${error.message}`);
+        return { content: [{ type: "text", text: `❌ Execution error: ${error.message}` }], isError: true };
     }
 };
 toolHandlers.set("query-graphql", queryGraphqlHandler);
-(0, tool_registry_js_1.registerTool)(server, toolHandlers, registeredToolsMetadata, "query-graphql", "Execute a GraphQL query against the endpoint", {
-    query: zod_1.default.string(),
-    variables: zod_1.default.string().optional(),
-    headers: zod_1.default.string().optional(),
+(0, tool_registry_js_1.registerTool)(server, toolHandlers, registeredToolsMetadata, "query-graphql", "Execute a GraphQL query across all nodes in the federated system", {
+    query: zod_1.default.string().describe("The GraphQL query or mutation string"),
+    variables: zod_1.default.string().optional().describe("JSON string of variables"),
+    headers: zod_1.default.string().optional().describe("JSON string of extra headers"),
 }, queryGraphqlHandler);
 /**
  * Tool: introspect-schema
- * Provides schema exploration with built-in agent recovery logic.
+ * Provides a global view of all nodes and resolves type conflicts.
  */
 const introspectHandler = async ({ typeNames }) => {
-    const result = await getSchema(true);
-    if (!result || typeof result === 'string') {
-        return {
-            content: [{
-                    type: "text",
-                    text: `❌ SCHEMA_ERROR: ${typeof result === 'string' ? result : 'GraphQL schema is not initialized yet.'}\n` +
-                        `ACTION: Please wait 5-10 seconds for the backend endpoint to respond.`
-                }]
-        };
-    }
-    const schema = result;
-    const typeMap = schema.getTypeMap();
-    const queryType = schema.getQueryType();
-    const queryFields = queryType ? queryType.getFields() : {};
-    const mutationType = schema.getMutationType();
-    const mutationFields = mutationType ? mutationType.getFields() : {};
-    // Gap analysis for requested types
-    if (typeNames && typeNames.length > 0) {
-        const missing = typeNames.filter(name => {
-            const existsAsType = !!typeMap[name];
-            const existsAsMutation = !!mutationFields[name];
-            const existsAsQueryField = !!queryFields[name];
-            return !existsAsType && !existsAsMutation && !existsAsQueryField;
-        });
-        if (missing.length > 0) {
-            const internalTypes = ['Query', 'Mutation', 'Subscription'];
-            const availableEntities = Object.keys(typeMap).filter(t => !t.startsWith('__') && !internalTypes.includes(t));
-            const schemaVersion = `v${availableEntities.length}.${Math.floor(Date.now() / 10000) % 1000}`;
-            return {
-                content: [{
-                        type: "text",
-                        text: `❌ PARTIAL RESULTS [Schema ID: ${schemaVersion}]\n\n` +
-                            `MISSING ENTITIES: ${missing.join(", ")}\n` +
-                            `REASON: Requested entities not found.\n` +
-                            `ACTION: Re-examine available types below.\n\n` +
-                            `AVAILABLE_ENTITIES: ${availableEntities.join(", ")}`
-                    }]
-            };
-        }
+    await getSchema(true);
+    if (cachedSchemas.length === 0) {
+        return { content: [{ type: "text", text: "❌ System is not initialized." }] };
     }
-    // Return general manifest if no specific types requested
+    // Default: Return the Manifest of all nodes
     if (!typeNames || typeNames.length === 0) {
-        const discoveredEntities = new Set();
-        if (queryType) {
-            const fields = queryType.getFields();
-            Object.values(fields).forEach((field) => {
-                const namedType = (0, graphql_1.getNamedType)(field.type);
-                if ((0, graphql_1.isObjectType)(namedType) && !namedType.name.startsWith('__')) {
-                    discoveredEntities.add(namedType.name);
-                }
-            });
+        const manifest = global.nodeManifest || [];
+        const body = manifest.map((m) => `🌐 NODE: ${m.endpoint}\n   ACTIONS: ${m.availableMutations.join(', ') || 'none'}\n   ENTITIES: ${m.domainEntities.join(', ')}`).join('\n\n');
+        return { content: [{ type: "text", text: `FEDERATED SCHEMA OVERVIEW\n\n${body}` }] };
+    }
+    const resolution = {};
+    for (const name of typeNames) {
+        const variants = [];
+        for (const schema of cachedSchemas) {
+            const found = (0, introspection_js_1.introspectSpecificTypes)(schema, [name]);
+            if (found && found[name]) {
+                variants.push({ origin: schema._originUrl, data: found[name] });
+            }
+        }
+        if (variants.length === 0)
+            continue;
+        if (variants.length === 1) {
+            resolution[name] = variants[0].data;
+        }
+        else {
+            // Check for structural equality
+            const baseline = JSON.stringify(variants[0].data);
+            const allMatch = variants.every(v => JSON.stringify(v.data) === baseline);
+            if (allMatch) {
+                resolution[name] = variants[0].data;
+            }
+            else {
+                // Conflict: Expose all variants with node origin
+                variants.forEach((v, idx) => {
+                    resolution[`${name}_from_node_${idx + 1}`] = {
+                        ...v.data,
+                        _meta: { origin_node: v.origin, conflict: "Structural difference detected across schemas" }
+                    };
+                });
+            }
         }
-        const entryPoints = Array.from(discoveredEntities).sort();
-        const allTypes = Object.keys(typeMap).filter(t => !t.startsWith('__'));
-        const schemaVersion = `v${allTypes.length}.${Math.floor(Date.now() / 10000) % 1000}`;
-        return {
-            content: [{
-                    type: "text",
-                    text: `GraphQL Schema Manifest [ID: ${schemaVersion}]\n\n` +
-                        `ENTRY_POINT_ENTITIES: ${entryPoints.join(", ") || "None"}\n` +
-                        `TOTAL_SCHEMA_TYPES: ${allTypes.length}\n\n` +
-                        `ALL_AVAILABLE_TYPES: ${allTypes.join(", ")}`
-                }]
-        };
     }
-    const filtered = (0, introspection_js_1.introspectSpecificTypes)(schema, typeNames);
     return {
-        content: [{ type: "text", text: JSON.stringify(filtered, null, 2) }]
+        content: [{
+                type: "text",
+                text: JSON.stringify(resolution, null, 2)
+            }]
     };
 };
 toolHandlers.set("introspect-schema", introspectHandler);
-(0, tool_registry_js_1.registerTool)(server, toolHandlers, registeredToolsMetadata, "introspect-schema", "Introspect the GraphQL schema with optional type filtering", {
-    typeNames: zod_1.default.array(zod_1.default.string()).optional(),
+(0, tool_registry_js_1.registerTool)(server, toolHandlers, registeredToolsMetadata, "introspect-schema", "Retrieve full type definitions and resolve conflicts across all system nodes", {
+    typeNames: zod_1.default.array(zod_1.default.string()).optional().describe("List of type names to introspect"),
 }, introspectHandler);
-// --- PROMPTS ---
-(0, prompt_registry_js_1.registerPrompt)(server, "health-check", "Check if the GraphQL endpoint is alive", "Run 'query-graphql' with query '{ __typename }' to verify connection.");
-(0, prompt_registry_js_1.registerPrompt)(server, "schema-overview", "List all available types", "Run 'introspect-schema' to see all types and entry points.");
-(0, prompt_registry_js_1.registerPrompt)(server, "list-scalars", "List all scalar types", "Run 'introspect-schema' and identify all scalars in the schema.");
-// --- HTTP SERVER LOGIC ---
-/**
- * Local HTTP server to support GraphiQL UI and SSE transport
- */
+// --- PROMPT REGISTRY ---
+(0, prompt_registry_js_1.registerPrompt)(server, "system-health", "Check status of all nodes", "Perform a simple __typename query on all endpoints.");
+// --- HTTP ADAPTER FOR GRAPHIQL & SSE ---
 async function handleHttpRequest(req, res) {
-    // Standard CORS headers
     res.setHeader('Access-Control-Allow-Origin', '*');
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, x-mcp-protocol-version, x-mcp-sdk-version');
+    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}`);
-    // Render GraphiQL UI
     if (req.method === 'GET' && (url.pathname === '/' || url.pathname === '/graphiql')) {
         res.writeHead(200, { 'Content-Type': 'text/html' });
-        return res.end((0, graphiql_js_1.renderGraphiQL)(`http://localhost:6274/mcp`, env.HEADERS));
+        return res.end((0, graphiql_js_1.renderGraphiQL)(`http://localhost:${env.MCP_PORT}/mcp`, env.HEADERS));
     }
-    // Process MCP/GraphQL requests
     if (url.pathname === '/mcp' && req.method === 'POST') {
         let body = '';
         req.on('data', chunk => { body += chunk; });
         req.on('end', async () => {
-            let requestId = null;
             try {
                 const payload = JSON.parse(body);
-                // Handle raw GraphQL queries (e.g., from Docs or Playground)
-                if (!payload.method && payload.query) {
-                    const handler = toolHandlers.get("query-graphql");
-                    if (handler) {
-                        const mcpResult = await handler({ query: payload.query, variables: payload.variables });
-                        const parsed = JSON.parse(mcpResult.content[0].text);
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        const graphQLResponse = parsed.result.data ? parsed.result : { data: parsed.result };
-                        return res.end(JSON.stringify(graphQLResponse));
-                    }
-                }
-                // Standard MCP JSON-RPC handling
                 const { method, id, params } = payload;
-                requestId = id;
-                let targetMethod = method;
-                let toolArgs = params;
-                if (method === "call-tool" || method === "tools/call") {
-                    targetMethod = params.name;
-                    toolArgs = params.arguments;
-                }
-                const handler = toolHandlers.get(targetMethod);
+                const target = (method === "call-tool" || method === "tools/call") ? params.name : method;
+                const args = (method === "call-tool" || method === "tools/call") ? params.arguments : params;
+                const handler = toolHandlers.get(target);
                 if (!handler) {
                     res.writeHead(404);
-                    return res.end(JSON.stringify({
-                        jsonrpc: '2.0',
-                        id: requestId,
-                        error: { code: -32601, message: `Tool ${targetMethod} not found` }
-                    }));
+                    return res.end(JSON.stringify({ error: { code: -32601, message: "Method not found" } }));
                 }
-                const result = await handler(toolArgs);
+                const result = await handler(args);
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ jsonrpc: '2.0', id: requestId, result }));
+                res.end(JSON.stringify({ jsonrpc: '2.0', id, result }));
             }
             catch (e) {
-                console.error(`[HTTP-ERROR] ${e.message}`);
                 res.writeHead(500);
-                res.end(JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: requestId,
-                    error: { code: -32603, message: e.message }
-                }));
+                res.end(JSON.stringify({ error: { message: e.message } }));
             }
         });
         return;
@@ -484,34 +369,32 @@ async function handleHttpRequest(req, res) {
     res.writeHead(404);
     res.end("Not Found");
 }
-// --- STARTUP ---
+// --- SERVER LIFECYCLE ---
 async function main() {
     const isInspector = !!(process.env.MCP_INSPECTOR || process.env.INSPECTOR_PORT);
-    const isHttpExplicitlyEnabled = process.env.ENABLE_HTTP === "true";
-    // Enable HTTP port by default unless explicitly disabled or in inspector mode
     if (process.env.ENABLE_HTTP !== "false" && !isInspector) {
-        const serverHttp = node_http_1.default.createServer(handleHttpRequest);
-        serverHttp.on('error', (e) => {
-            if (e.code === 'EADDRINUSE') {
-                console.error(`[HTTP-ERROR] Port ${env.MCP_PORT} is busy.`);
-            }
+        const httpSrv = node_http_1.default.createServer(handleHttpRequest);
+        httpSrv.on('error', (e) => {
+            if (e.code === 'EADDRINUSE')
+                console.error(`[ERROR] Port ${env.MCP_PORT} already in use.`);
         });
-        serverHttp.listen(env.MCP_PORT, () => {
-            console.error(`[SYSTEM] Server "${env.NAME}" v${getVersion()} active`);
-            console.error(`🤖 MCP SSE: http://localhost:${env.MCP_PORT}/mcp`);
-            if (isHttpExplicitlyEnabled) {
-                console.error(`🎨 GraphiQL UI: http://localhost:${env.MCP_PORT}/graphiql`);
+        httpSrv.listen(env.MCP_PORT, () => {
+            console.error(`[SYSTEM] Federated Bridge v${getVersion()} active on port ${env.MCP_PORT}`);
+            console.error(`📡 SSE Endpoint: http://localhost:${env.MCP_PORT}/mcp`);
+            if (process.env.ENABLE_HTTP === "true") {
+                console.error(`🎨 GraphiQL: http://localhost:${env.MCP_PORT}/graphiql`);
             }
         });
     }
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
-    // Background schema initialization
-    getSchema().catch(() => { });
+    // Initial background sync
+    getSchema(true).catch(err => console.error(`[BOOT-WARN] Initial sync failed: ${err.message}`));
 }
-process.on('SIGINT', () => process.exit(0));
-process.on('SIGTERM', () => process.exit(0));
-main().catch(error => {
-    console.error(`[FATAL] ${error}`);
+// Global process management
+process.on('SIGINT', () => { console.error('[SYSTEM] Shutting down...'); process.exit(0); });
+process.on('SIGTERM', () => { process.exit(0); });
+main().catch(err => {
+    console.error(`[FATAL] Startup failed: ${err.message}`);
     process.exit(1);
 });

package/package.json

@@ -50,5 +50,5 @@
 		"tsx": "^4.21.0",
 		"typescript": "5.8.3"
 	},
-	"version": "3.9.0"
+	"version": "3.9.1"
 }