@samanhappy/mcphub 1.1.0 → 1.1.2

package/dist/services/mcpService.js

@@ -5,6 +5,7 @@ import { LegacyMcpClient } from '../clients/legacyMcpClient.js';
 import { LEGACY_PROTOCOL_VERSIONS } from '../utils/mcpProtocol.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { canAccessGroupRoute } from '../utils/groupAccess.js';
+import { canServeToolRequests } from '../utils/serverAvailability.js';
 import { PrincipalRuntimeService } from './principalRuntimeService.js';
 import { UserContextService } from './userContextService.js';
 import { deleteCredentialBindings, missingCredentialError } from './credentialBindingService.js';
@@ -15,7 +16,7 @@ import fs from 'fs';
 import treeKill from 'tree-kill';
 import { isProcessTreeKillAvailable } from '../utils/processTree.js';
 import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
-import { SSEClientTransport, StreamableHTTPClientTransport, } from '@modelcontextprotocol/client';
+import { SSEClientTransport, StreamableHTTPClientTransport, } from '../clients/mcpSdkClient.js';
 import { Server } from '@modelcontextprotocol/server';
 import { createFetchWithProxy, getProxyConfigFromEnv } from './proxy.js';
 import { assertSafeUrl, createRedirectValidatingFetch } from '../utils/ssrf.js';
@@ -24,6 +25,7 @@ import { ResilientJsonSchemaValidator } from '../utils/jsonSchemaValidator.js';
 import { getUserDao } from '../dao/index.js';
 import { expandEnvVars, replaceEnvVars, getNameSeparator } from '../config/index.js';
 import config from '../config/index.js';
+import { validateMaxBufferSize } from '../utils/stdioOptions.js';
 import { validateServerName } from '../utils/serverNameValidation.js';
 import { getGroup } from './sseService.js';
 import { getServerConfigInGroup, normalizeGroupServers } from './groupService.js';
@@ -1293,6 +1295,7 @@ export const createTransportFromConfig = async (name, conf) => {
             args: finalArgs,
             env: env,
             stderr: 'pipe',
+            maxBufferSize: validateMaxBufferSize(conf.options?.maxBufferSize),
         });
         if (transport.stderr && hasCredentialTemplate(conf)) {
             transport.stderr.on('data', () => undefined); // Personal upstream diagnostics can contain raw credentials.
@@ -1390,6 +1393,7 @@ const callToolWithReconnect = async (serverInfo, toolParams, options, maxRetries
                         serverInfo.client = newClient;
                         serverInfo.transport = newTransport;
                         serverInfo.status = 'connected';
+                        setupServerKeepAlive(serverInfo, server);
                     }
                     // Point the local refs at the new connection for the next attempt.
                     client = newClient;
@@ -2333,6 +2337,7 @@ const classifyUnavailableReason = (qualifiedName) => {
 };
 // Add new server
 export const addServer = async (name, config) => {
+    validateMaxBufferSize(config.options?.maxBufferSize);
     validateCredentialTemplate(config);
     const server = { name, ...config };
     const result = await getServerDao().create(server);
@@ -2367,6 +2372,7 @@ export const removeServer = async (name) => {
 // Add or update server (supports overriding existing servers for MCPB)
 export const addOrUpdateServer = async (name, config, allowOverride = false) => {
     try {
+        validateMaxBufferSize(config.options?.maxBufferSize);
         validateCredentialTemplate(config);
         const exists = await getServerDao().exists(name);
         if (exists && !allowOverride) {
@@ -2664,12 +2670,19 @@ const primeOnDemandServers = (gate) => {
     const run = gate ? gate.run : (start) => start();
     return Promise.allSettled(targets.map(async (si) => {
         try {
-            await run(() => ensureServerReady(si));
+            await run(() => ensureServerReady(si), 
+            // A reload may replace this runtime or finish its discovery while it
+            // waits for a slot. Neither needs another child from the old queue.
+            () => serverInfos.includes(si) && si.enabled !== false && si.tools.length === 0);
             // Sleep the child unless a tool call is using it; keep the cached tool list.
             shutdownOnDemandServer(si);
             logger.log('On-demand server tool cache primed');
         }
         catch (error) {
+            if (error instanceof QueuedConnectCancelledError) {
+                logger.log('Cancelled queued on-demand discovery', { serverName: si.name });
+                return;
+            }
             logger.warn('Failed to prime on-demand server', {
                 error: summarizeErrorForLogging(error),
             });
@@ -2837,9 +2850,21 @@ const getMcpAppsRouteContext = async (sessionId, group) => {
         : sessionId
             ? servers[sessionId]?.getClientCapabilities()
             : undefined;
-    if (isSmartRoutingGroup(group) || !hasMcpAppsCapability(clientCapabilities)) {
+    if (!hasMcpAppsCapability(clientCapabilities)) {
         return { enabled: false };
     }
+    if (isSmartRoutingGroup(group)) {
+        // Only pinned tools are listed under their own descriptor, so only the servers
+        // that pin something can own a widget here. Always the multi-server shape:
+        // names stay qualified and calls resolve through the group, so a pin never
+        // widens what the group allows.
+        const pinned = await resolvePinnedSmartRoutingServers(group);
+        // An idle on-demand server still advertises its cached tools, so it keeps its
+        // widget link: dropping it here would hand the host a descriptor without one
+        // that the next call, which wakes the server, can no longer correct.
+        const eligible = (pinned?.pinnedServerInfos ?? []).filter(canServeToolRequests);
+        return eligible.length > 0 ? { enabled: true, serverInfos: eligible } : { enabled: false };
+    }
     const { filteredServerInfos } = await getFilteredServerInfosForGroup(group);
     const connectedServerInfos = filteredServerInfos.filter((serverInfo) => serverInfo.status === 'connected' && !!serverInfo.client);
     if (connectedServerInfos.length === 0) {
@@ -2938,11 +2963,8 @@ const resolveToolInGroup = async (group, toolName) => {
         serverConfigsByName.size <= 1 &&
         filteredServerInfos.length === 1;
     for (const serverInfo of filteredServerInfos) {
-        // A disconnected on-demand server may still have a cached tool list from a
-        // previous wake-up; allow it through so it can be selected and woken by the
-        // caller. Other disconnected servers cannot serve the request. See #1029.
-        if ((serverInfo.status !== 'connected' && !serverInfo.config?.startOnDemand) ||
-            serverInfo.enabled === false) {
+        // An idle on-demand server is selected here and woken by the caller (#1029)
+        if (!canServeToolRequests(serverInfo)) {
             continue;
         }
         const serverConfig = serverConfigsByName.get(serverInfo.name);
@@ -3038,13 +3060,12 @@ const listGroupTools = async (group, filteredServerInfos, serverConfigsByName, a
 // Names the call handler always routes to a meta-tool on a Smart Routing session,
 // whichever of them the current mode lists (see handleCallToolRequestImpl)
 const SMART_ROUTING_META_TOOL_NAMES = new Set(['search_tools', 'describe_tool', 'call_tool']);
-// Tools a $smart/<group> lists next to its meta-tools: each member's pinnedTools,
-// narrowed to its tools selection and then run through the same filtering and
-// projection as a direct group listing.
-const getPinnedSmartRoutingTools = async (group) => {
+// Each member's pinnedTools, narrowed to its tools selection. Empty when the
+// route is not a $smart/<group> or the group pins nothing.
+const resolvePinnedSmartRoutingServers = async (group) => {
     const lookupGroup = getGroupLookupName(group);
     if (!lookupGroup) {
-        return [];
+        return undefined;
     }
     const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(lookupGroup);
     const pinnedConfigsByName = new Map();
@@ -3056,9 +3077,23 @@ const getPinnedSmartRoutingTools = async (group) => {
         }
     }
     if (pinnedConfigsByName.size === 0) {
+        return undefined;
+    }
+    return {
+        lookupGroup,
+        pinnedServerInfos: filteredServerInfos.filter((serverInfo) => pinnedConfigsByName.has(serverInfo.name)),
+        pinnedConfigsByName,
+    };
+};
+// Tools a $smart/<group> lists next to its meta-tools: each member's pinnedTools,
+// narrowed to its tools selection and then run through the same filtering and
+// projection as a direct group listing.
+const getPinnedSmartRoutingTools = async (group, appsRouteContext = { enabled: false }) => {
+    const pinned = await resolvePinnedSmartRoutingServers(group);
+    if (!pinned) {
         return [];
     }
-    return listGroupTools(lookupGroup, filteredServerInfos.filter((serverInfo) => pinnedConfigsByName.has(serverInfo.name)), pinnedConfigsByName, { enabled: false });
+    return listGroupTools(pinned.lookupGroup, pinned.pinnedServerInfos, pinned.pinnedConfigsByName, appsRouteContext);
 };
 const handleListToolsRequestImpl = async (_, extra) => {
     const sessionId = extra.sessionId || '';
@@ -3070,10 +3105,11 @@ const handleListToolsRequestImpl = async (_, extra) => {
         const smartRoutingTools = await getSmartRoutingTools(group);
         let pinnedTools = [];
         try {
+            const appsRouteContext = await getMcpAppsRouteContext(sessionId, group);
             // A pin named like a meta-tool (e.g. alias "describe" + separator "_" +
             // tool "tool") would be intercepted by it on call, even in a mode that
             // does not list that meta-tool, so it is not listed at all
-            pinnedTools = (await getPinnedSmartRoutingTools(group)).filter((tool) => !SMART_ROUTING_META_TOOL_NAMES.has(tool.name));
+            pinnedTools = (await getPinnedSmartRoutingTools(group, appsRouteContext)).filter((tool) => !SMART_ROUTING_META_TOOL_NAMES.has(tool.name));
         }
         catch (error) {
             // Pins are an optimisation: failing to resolve them must not cost the meta-tools