@enfyra/mcp-server 0.0.92 → 0.0.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enfyra/mcp-server",
-  "version": "0.0.92",
+  "version": "0.0.93",
   "description": "MCP server for Enfyra - manage Enfyra instances from MCP-compatible coding tools",
   "type": "module",
   "license": "MIT",

package/src/mcp-server-entry.mjs

@@ -13,6 +13,7 @@ import { createHash } from 'node:crypto';
 // Configuration
 const ENFYRA_API_URL = process.env.ENFYRA_API_URL || 'http://localhost:3000/api';
 const ENFYRA_API_TOKEN = process.env.ENFYRA_API_TOKEN || '';
+const DISCOVERY_FETCH_TIMEOUT_MS = 12000;
 
 // Import modules
 import { exchangeApiToken, refreshAccessToken, getValidToken, resetTokens, getTokenExpiry, initAuth } from './lib/auth.js';
@@ -360,6 +361,36 @@ function targetInstance() {
   };
 }
 
+async function discoveryFetch(path, { fallbackData = [], timeoutMs = DISCOVERY_FETCH_TIMEOUT_MS } = {}) {
+  let timeoutId;
+  try {
+    const timeout = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new Error(`Discovery request timeout after ${timeoutMs}ms for ${path}`));
+      }, timeoutMs);
+    });
+    return await Promise.race([
+      fetchAPI(ENFYRA_API_URL, path),
+      timeout,
+    ]);
+  } catch (error) {
+    return {
+      statusCode: null,
+      success: false,
+      error: String(error?.message || error),
+      data: fallbackData,
+    };
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
+
+function collectPartialErrors(results) {
+  return Object.entries(results)
+    .filter(([, result]) => result?.error)
+    .map(([name, result]) => ({ name, error: result.error }));
+}
+
 async function getMetadataTables() {
   const metadata = await fetchAPI(ENFYRA_API_URL, '/metadata');
   return {
@@ -628,11 +659,9 @@ server.tool(
   ].join(' '),
   {},
   async () => {
-    const metadata = await fetchAPI(ENFYRA_API_URL, '/metadata');
-    const [routesResult, methodsResult] = await Promise.all([
-      fetchAPI(ENFYRA_API_URL, '/enfyra_route?fields=path,mainTable.name,availableMethods.*,publicMethods.*&limit=1000'),
-      fetchAPI(ENFYRA_API_URL, '/enfyra_method?limit=100'),
-    ]);
+    const metadata = await discoveryFetch('/metadata');
+    const routesResult = await discoveryFetch('/enfyra_route?fields=path,mainTable.name,availableMethods.*,publicMethods.*&limit=1000');
+    const methodsResult = await discoveryFetch('/enfyra_method?limit=100');
 
     const tables = normalizeTables(metadata);
     const tableNames = tables.map((table) => table?.name).filter(Boolean).sort();
@@ -647,6 +676,7 @@ server.tool(
     const payload = {
       targetInstance: targetInstance(),
       apiBase: ENFYRA_API_URL.replace(/\/$/, ''),
+      partialErrors: collectPartialErrors({ metadata, routesResult, methodsResult }),
       counts: {
         tables: tableNames.length,
         routes: routes.length,
@@ -709,26 +739,15 @@ server.tool(
   ].join(' '),
   {},
   async () => {
-    const metadata = await fetchAPI(ENFYRA_API_URL, '/metadata');
-    const [
-      routesResult,
-      methodsResult,
-      gqlResult,
-      flowsResult,
-      websocketResult,
-      storageResult,
-      settingsResult,
-      meResult,
-    ] = await Promise.all([
-      fetchAPI(ENFYRA_API_URL, '/enfyra_route?fields=path,mainTable.name,availableMethods.*,publicMethods.*,isEnabled&limit=1000'),
-      fetchAPI(ENFYRA_API_URL, '/enfyra_method?limit=100'),
-      fetchAPI(ENFYRA_API_URL, '/enfyra_graphql?limit=1000').catch((error) => ({ error: String(error.message || error), data: [] })),
-      fetchAPI(ENFYRA_API_URL, '/enfyra_flow?limit=1000').catch((error) => ({ error: String(error.message || error), data: [] })),
-      fetchAPI(ENFYRA_API_URL, '/enfyra_websocket?limit=1000').catch((error) => ({ error: String(error.message || error), data: [] })),
-      fetchAPI(ENFYRA_API_URL, '/enfyra_storage_config?limit=1000').catch((error) => ({ error: String(error.message || error), data: [] })),
-      fetchAPI(ENFYRA_API_URL, '/enfyra_setting?limit=1000').catch((error) => ({ error: String(error.message || error), data: [] })),
-      fetchAPI(ENFYRA_API_URL, '/me').catch((error) => ({ error: String(error.message || error), data: [] })),
-    ]);
+    const metadata = await discoveryFetch('/metadata');
+    const routesResult = await discoveryFetch('/enfyra_route?fields=path,mainTable.name,availableMethods.*,publicMethods.*,isEnabled&limit=1000');
+    const methodsResult = await discoveryFetch('/enfyra_method?limit=100');
+    const gqlResult = await discoveryFetch('/enfyra_graphql?limit=1000');
+    const flowsResult = await discoveryFetch('/enfyra_flow?limit=1000');
+    const websocketResult = await discoveryFetch('/enfyra_websocket?limit=1000');
+    const storageResult = await discoveryFetch('/enfyra_storage_config?limit=1000');
+    const settingsResult = await discoveryFetch('/enfyra_setting?limit=1000');
+    const meResult = await discoveryFetch('/me', { fallbackData: null });
 
     const tables = normalizeTables(metadata);
     const routes = summarizeRoutes(routesResult);
@@ -739,6 +758,17 @@ server.tool(
     const payload = {
       targetInstance: targetInstance(),
       apiBase: ENFYRA_API_URL.replace(/\/$/, ''),
+      partialErrors: collectPartialErrors({
+        metadata,
+        routesResult,
+        methodsResult,
+        gqlResult,
+        flowsResult,
+        websocketResult,
+        storageResult,
+        settingsResult,
+        meResult,
+      }),
       authenticatedUser: Array.isArray(meResult?.data) ? meResult.data[0] || null : meResult?.data || null,
       database: getMetadataDatabaseContext(metadata, tables),
       counts: {
@@ -795,8 +825,8 @@ server.tool(
     tableName: z.string().optional().describe('Optional table name to summarize query fields and relation/deep capabilities.'),
   },
   async ({ tableName }) => {
-    const metadata = await fetchAPI(ENFYRA_API_URL, '/metadata');
-    const routesResult = await fetchAPI(ENFYRA_API_URL, '/enfyra_route?fields=path,mainTable.name,availableMethods.*,publicMethods.*,isEnabled&limit=1000');
+    const metadata = await discoveryFetch('/metadata');
+    const routesResult = await discoveryFetch('/enfyra_route?fields=path,mainTable.name,availableMethods.*,publicMethods.*,isEnabled&limit=1000');
     const tables = normalizeTables(metadata);
     const routes = summarizeRoutes(routesResult);
     const table = tableName ? tables.find((item) => item.name === tableName) : null;
@@ -807,6 +837,7 @@ server.tool(
 
     const payload = {
       targetInstance: targetInstance(),
+      partialErrors: collectPartialErrors({ metadata, routesResult }),
       operators: {
         filter: FILTER_OPERATORS,
         fieldPermissionConditions: FIELD_PERMISSION_CONDITION_OPERATORS,
@@ -1703,6 +1734,51 @@ async function collectRestDefinitionState() {
   };
 }
 
+async function collectFeatureSearchState() {
+  const metadata = await discoveryFetch('/metadata');
+  const routesResult = await discoveryFetch('/enfyra_route?limit=500');
+  const handlersResult = await discoveryFetch('/enfyra_route_handler?limit=500');
+  const preHooksResult = await discoveryFetch('/enfyra_pre_hook?limit=500');
+  const postHooksResult = await discoveryFetch('/enfyra_post_hook?limit=500');
+  const routePermissionsResult = await discoveryFetch('/enfyra_route_permission?limit=500');
+  const guardsResult = await discoveryFetch('/enfyra_guard?limit=500');
+  const guardRulesResult = await discoveryFetch('/enfyra_guard_rule?limit=500');
+  const fieldPermissionsResult = await discoveryFetch('/enfyra_field_permission?limit=500');
+  const columnRulesResult = await discoveryFetch('/enfyra_column_rule?limit=500');
+  const methodsResult = await discoveryFetch('/enfyra_method?limit=100');
+  const methodIdNameMap = Object.fromEntries(
+    unwrapData(methodsResult).map((method) => [String(getId(method)), method.name]),
+  );
+
+  return {
+    metadata,
+    tables: normalizeTables(metadata),
+    routes: unwrapData(routesResult),
+    handlers: unwrapData(handlersResult),
+    preHooks: unwrapData(preHooksResult),
+    postHooks: unwrapData(postHooksResult),
+    routePermissions: unwrapData(routePermissionsResult),
+    guards: unwrapData(guardsResult),
+    guardRules: unwrapData(guardRulesResult),
+    fieldPermissions: unwrapData(fieldPermissionsResult),
+    columnRules: unwrapData(columnRulesResult),
+    methodIdNameMap,
+    partialErrors: collectPartialErrors({
+      metadata,
+      routesResult,
+      handlersResult,
+      preHooksResult,
+      postHooksResult,
+      routePermissionsResult,
+      guardsResult,
+      guardRulesResult,
+      fieldPermissionsResult,
+      columnRulesResult,
+      methodsResult,
+    }),
+  };
+}
+
 function enrichRoute(route, state) {
   const routeId = getId(route);
   const routeHandlers = state.handlers
@@ -1868,7 +1944,7 @@ server.tool(
       throw new Error('inspect_feature query must be at least 2 characters. Use a table name, route path, event name, or specific feature keyword.');
     }
     const max = Math.max(1, Math.min(Number(limit || 8), 25));
-    const state = await collectRestDefinitionState();
+    const state = await collectFeatureSearchState();
     const q = rawQuery.toLowerCase();
     const matchesText = (value) => JSON.stringify(value ?? '').toLowerCase().includes(q);
     const tableMatches = state.tables.filter((table) => matchesText({
@@ -1892,6 +1968,7 @@ server.tool(
       targetInstance: targetInstance(),
       query: rawQuery,
       limit: max,
+      partialErrors: state.partialErrors,
       counts: {
         tables: tableMatches.length,
         routes: routeMatches.length,