@samanhappy/mcphub 1.0.46 → 1.1.1

package/dist/services/mcpService.js

@@ -1,9 +1,11 @@
+import { preserveListFreshness, combineListFreshness, remainingListTtl, } from '../utils/listFreshness.js';
 import { expandServerConfig, getServerEnvironment } from './serverConfigEnvironment.js';
 import { getMcpRequestGroup } from '../utils/mcpRequestGroup.js';
 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';
@@ -23,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';
@@ -30,7 +33,7 @@ import { removeServerToolEmbeddings, removeToolEmbeddings, saveToolsAsVectorEmbe
 import { OpenAPIClient } from '../clients/openapi.js';
 import { RequestContextService } from './requestContextService.js';
 import { getDataService } from './services.js';
-import { getServerDao, getGroupDao, getSystemConfigDao, getBuiltinPromptDao, getBuiltinResourceDao, } from '../dao/index.js';
+import { getBearerKeyDao, getServerDao, getGroupDao, getSystemConfigDao, getBuiltinPromptDao, getBuiltinResourceDao, } from '../dao/index.js';
 import { initializeAllOAuthClients } from './oauthService.js';
 import { createOAuthProvider } from './mcpOAuthProvider.js';
 import { initSmartRoutingService, getSmartRoutingTools, handleSearchToolsRequest, handleDescribeToolRequest, isSmartRoutingGroup, } from './smartRoutingService.js';
@@ -782,7 +785,7 @@ export const setServerInfosForTest = (infos) => {
     serverInfos = infos;
 };
 export const updateServerToolsCache = (serverInfo, tools, options) => {
-    serverInfo.tools = tools.map((tool) => normalizeToolForCache(serverInfo.name, tool));
+    serverInfo.tools = preserveListFreshness(tools, tools.map((tool) => normalizeToolForCache(serverInfo.name, tool)));
     syncToolsAsVectorEmbeddings(serverInfo.name, serverInfo.tools, {
         reportProgress: options?.reportEmbeddingProgress === true,
     }).catch(() => {
@@ -790,10 +793,10 @@ export const updateServerToolsCache = (serverInfo, tools, options) => {
     });
 };
 const updateServerPromptsCache = (serverInfo, prompts) => {
-    serverInfo.prompts = prompts.map((prompt) => normalizePromptForCache(serverInfo.name, prompt));
+    serverInfo.prompts = preserveListFreshness(prompts, prompts.map((prompt) => normalizePromptForCache(serverInfo.name, prompt)));
 };
 const updateServerResourcesCache = (serverInfo, resources) => {
-    serverInfo.resources = resources.map(normalizeResourceForCache);
+    serverInfo.resources = preserveListFreshness(resources, resources.map(normalizeResourceForCache));
 };
 const logListChangedRefreshError = (listType) => {
     logger.warn(`Failed to refresh ${listType} list after upstream notification`);
@@ -807,6 +810,7 @@ const createUpstreamMcpClient = (name, getServerInfo) => {
         jsonSchemaValidator: new ResilientJsonSchemaValidator(),
         listChanged: {
             tools: {
+                debounceMs: 0,
                 onChanged: (error, tools) => {
                     const serverInfo = getServerInfo();
                     if (error) {
@@ -821,6 +825,7 @@ const createUpstreamMcpClient = (name, getServerInfo) => {
                 },
             },
             prompts: {
+                debounceMs: 0,
                 onChanged: (error, prompts) => {
                     const serverInfo = getServerInfo();
                     if (error) {
@@ -835,6 +840,7 @@ const createUpstreamMcpClient = (name, getServerInfo) => {
                 },
             },
             resources: {
+                debounceMs: 0,
                 onChanged: (error, resources) => {
                     const serverInfo = getServerInfo();
                     if (error) {
@@ -1289,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.
@@ -1386,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;
@@ -2329,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);
@@ -2363,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) {
@@ -2934,11 +2944,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);
@@ -3764,19 +3771,24 @@ const handleListResourceTemplatesRequestImpl = async (_, extra) => {
     const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(lookupGroup, {
         requireClient: true,
     });
+    const snapshots = [];
     const results = await Promise.allSettled(filteredServerInfos.map(async (serverInfo) => {
         if (!serverInfo.client?.listResourceTemplates) {
             return [];
         }
         const templates = await serverInfo.client.listResourceTemplates({}, serverInfo.options || {});
+        snapshots.push(templates.resourceTemplates);
         const filteredTemplates = await filterResourceTemplatesByGroup(lookupGroup, serverInfo.name, templates.resourceTemplates || [], serverConfigsByName.get(serverInfo.name));
         return appsRouteContext.enabled
             ? filteredTemplates
             : filteredTemplates.map((template) => stripMcpAppsMetadata(template));
     }));
-    return {
-        resourceTemplates: results.flatMap((result) => result.status === 'fulfilled' ? result.value : []),
-    };
+    const resourceTemplates = results.flatMap((result) => result.status === 'fulfilled' ? result.value : []);
+    if (results.every((result) => result.status === 'fulfilled') &&
+        snapshots.length === filteredServerInfos.length) {
+        combineListFreshness(snapshots, resourceTemplates);
+    }
+    return { resourceTemplates };
 };
 const handleReadResourceRequestImpl = async (request, extra) => {
     try {
@@ -3954,12 +3966,18 @@ const createPrincipalRuntime = async (name, resolvedConfig) => {
             info.client = protectClient(client);
             await client.connect(transport, resolvedConfig.options || {});
             const capabilities = client.getServerCapabilities();
-            if (capabilities?.tools)
-                info.tools = (await client.listTools({}, resolvedConfig.options)).tools.map((tool) => normalizeToolForCache(name, tool));
-            if (capabilities?.prompts)
-                info.prompts = (await client.listPrompts({}, resolvedConfig.options)).prompts.map((prompt) => normalizePromptForCache(name, prompt));
-            if (capabilities?.resources)
-                info.resources = (await client.listResources({}, resolvedConfig.options)).resources.map(normalizeResourceForCache);
+            if (capabilities?.tools) {
+                const { tools } = await client.listTools({}, resolvedConfig.options);
+                info.tools = preserveListFreshness(tools, tools.map((tool) => normalizeToolForCache(name, tool)));
+            }
+            if (capabilities?.prompts) {
+                const { prompts } = await client.listPrompts({}, resolvedConfig.options);
+                info.prompts = preserveListFreshness(prompts, prompts.map((prompt) => normalizePromptForCache(name, prompt)));
+            }
+            if (capabilities?.resources) {
+                const { resources } = await client.listResources({}, resolvedConfig.options);
+                info.resources = preserveListFreshness(resources, resources.map(normalizeResourceForCache));
+            }
             info.version = client.getServerVersion()?.version;
             // Record the resolved npx/uvx package version backing this server.
             applyResolvedPackageVersion(info, resolvedConfig);
@@ -4111,14 +4129,82 @@ const withPrincipalServers = (handler, operation) => async (request, extra) => {
             release();
     }
 };
+// Re-read authoritative inputs across awaits; no projected response is cached.
+const listProjectionInputs = async (group, field) => {
+    const user = UserContextService.getInstance().getCurrentUser();
+    const keyId = RequestContextService.getInstance().getBearerKeyContext().keyId;
+    const liveUser = user?.username ? await getUserDao().findByUsername(user.username) : undefined;
+    const key = keyId ? await getBearerKeyDao().findById(keyId) : undefined;
+    if ((user?.username && (!liveUser || Boolean(user.isAdmin) !== Boolean(liveUser.isAdmin))) ||
+        (keyId && !key?.enabled))
+        return undefined;
+    const lookupGroup = getGroupLookupName(group);
+    const groupDao = getGroupDao();
+    let routeGroup = lookupGroup ? await groupDao.findByName(lookupGroup) : undefined;
+    if (!routeGroup &&
+        lookupGroup &&
+        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(lookupGroup)) {
+        routeGroup = await groupDao.findById(lookupGroup);
+    }
+    return JSON.stringify([
+        await getServerDao().findAll(),
+        routeGroup,
+        await getSystemConfigDao().get(),
+        field === 'prompts' ? await getBuiltinPromptDao().findEnabled() : undefined,
+        field === 'resources' ? await getBuiltinResourceDao().findEnabled() : undefined,
+        liveUser,
+        key,
+        RequestContextService.getInstance().getRequestContext()?.clientCapabilities,
+        getVisibleServerInfos().map((info) => ({
+            name: info.name,
+            status: info.status,
+            enabled: info.enabled,
+            owner: info.owner,
+            visibility: info.visibility,
+            sharedWithUsers: info.sharedWithUsers,
+            config: info.config,
+        })),
+    ]);
+};
 // Lists combine cached discovery with live gateway configuration and authorization.
 // Upstream freshness alone cannot guarantee freshness of the resulting projection.
-const withCacheHints = (handler, passthroughTtl = false) => async (request, extra) => {
+const withCacheHints = (handler, passthroughTtl = false, listField) => async (request, extra) => {
     if (!RequestContextService.getInstance().getRequestContext()?.stateless) {
         return handler(request, extra);
     }
     const startedAt = performance.now();
+    const group = getMcpRequestGroup(extra);
+    const inputs = listField ? await listProjectionInputs(group, listField) : undefined;
+    const before = listField
+        ? await getFilteredServerInfosForGroup(getGroupLookupName(group))
+        : undefined;
+    const snapshots = before && listField && listField !== 'resourceTemplates'
+        ? before.filteredServerInfos.map((info) => info[listField])
+        : [];
+    const clients = before?.filteredServerInfos.map((info) => info.client);
     const result = await handler(request, extra);
+    if (listField) {
+        const after = await getFilteredServerInfosForGroup(getGroupLookupName(group));
+        const stable = typeof inputs === 'string' &&
+            inputs === (await listProjectionInputs(group, listField)) &&
+            before?.filteredServerInfos.length === after.filteredServerInfos.length &&
+            before.filteredServerInfos.every((info, index) => info === after.filteredServerInfos[index] &&
+                info.client === clients?.[index] &&
+                info.status === 'connected' &&
+                (listField === 'resourceTemplates' || info[listField] === snapshots[index]));
+        const generated = (listField === 'tools' && isSmartRoutingGroup(group)) ||
+            (listField === 'prompts' && (await getBuiltinPromptDao().findEnabled()).length > 0) ||
+            (listField === 'resources' && (await getBuiltinResourceDao().findEnabled()).length > 0);
+        const unknownPermissions = RequestContextService.getInstance().getHostedAuthContext();
+        const dependencies = listField === 'resourceTemplates' ? [result.resourceTemplates] : snapshots;
+        return {
+            ...result,
+            ttlMs: stable && !generated && !unknownPermissions
+                ? remainingListTtl(dependencies, startedAt, performance.now())
+                : 0,
+            cacheScope: 'private',
+        };
+    }
     const upstreamTtl = result.ttlMs;
     const ttlMs = passthroughTtl &&
         typeof upstreamTtl === 'number' &&
@@ -4130,12 +4216,12 @@ const withCacheHints = (handler, passthroughTtl = false) => async (request, extr
     // and capabilities. Shared caches must not reuse the gateway result across users.
     return { ...result, ttlMs, cacheScope: 'private' };
 };
-export const handleListToolsRequest = withPrincipalServers(withCacheHints(handleListToolsRequestImpl), 'list');
+export const handleListToolsRequest = withPrincipalServers(withCacheHints(handleListToolsRequestImpl, false, 'tools'), 'list');
 export const handleCallToolRequest = withPrincipalServers(handleCallToolRequestImpl, 'tool');
 export const handleGetPromptRequest = withPrincipalServers(handleGetPromptRequestImpl, 'prompt');
-export const handleListPromptsRequest = withPrincipalServers(withCacheHints(handleListPromptsRequestImpl), 'list');
-export const handleListResourcesRequest = withPrincipalServers(withCacheHints(handleListResourcesRequestImpl), 'list');
-export const handleListResourceTemplatesRequest = withPrincipalServers(withCacheHints(handleListResourceTemplatesRequestImpl), 'list');
+export const handleListPromptsRequest = withPrincipalServers(withCacheHints(handleListPromptsRequestImpl, false, 'prompts'), 'list');
+export const handleListResourcesRequest = withPrincipalServers(withCacheHints(handleListResourcesRequestImpl, false, 'resources'), 'list');
+export const handleListResourceTemplatesRequest = withPrincipalServers(withCacheHints(handleListResourceTemplatesRequestImpl, false, 'resourceTemplates'), 'list');
 export const handleReadResourceRequest = withPrincipalServers(withCacheHints(handleReadResourceRequestImpl, true), 'resource');
 export const createMcpServer = (name, version, options) => {
     const normalizedOptions = typeof options === 'string' ? { group: options } : (options ?? {});