@samanhappy/mcphub 1.2.2 → 1.2.4

package/dist/services/mcpService.js

@@ -5,7 +5,7 @@ import { withReplicaLock } from './replicaLock.js';
 import { projectGroupToolName, assertValidGroupToolNames } from '../utils/groupToolNames.js';
 import { isSafePassthroughHeader } from '../utils/passthroughHeaders.js';
 import { observeToolCall, setMetricsServer } from './metricsService.js';
-import { hasPersonalOAuth, PersonalOAuthContext, personalOAuthContexts, personalAuthorizationRequired, } from './personalOAuthService.js';
+import { hasPersonalOAuth, PersonalOAuthContext, personalOAuthContexts, personalAuthorizationRequired, PersonalAuthorizationRequiredError, } from './personalOAuthService.js';
 import { preserveListFreshness, combineListFreshness, remainingListTtl, } from '../utils/listFreshness.js';
 import { expandServerConfig, getServerEnvironment } from './serverConfigEnvironment.js';
 import { getMcpRequestGroup } from '../utils/mcpRequestGroup.js';
@@ -17,6 +17,7 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { createHash } from 'node:crypto';
 import { canAccessGroupRoute } from '../utils/groupAccess.js';
 import { canServeToolRequests } from '../utils/serverAvailability.js';
+import { uriMatchesResourceTemplate } from '../utils/resourceTemplateMatch.js';
 import { assertToolCallArgumentsSafe, isToolCallGuardEnabled, ToolCallBlockedError, } from '../middlewares/toolCallGuard.js';
 import { applyHiddenParams, findToolConfig, removeHiddenArguments, } from '../utils/toolConfig.js';
 import { prepareCapabilitySnapshot, recordCapabilitySnapshot, flushCapabilitySnapshot, } from './capabilitySnapshotService.js';
@@ -31,7 +32,7 @@ import treeKill from 'tree-kill';
 import { isProcessTreeKillAvailable } from '../utils/processTree.js';
 import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
 import { SSEClientTransport, StreamableHTTPClientTransport, } from '../clients/mcpSdkClient.js';
-import { Server } from '@modelcontextprotocol/server';
+import { ProtocolError, Server } from '@modelcontextprotocol/server';
 import { createFetchWithProxy, getProxyConfigFromEnv } from './proxy.js';
 import { assertSafeUrl, createRedirectValidatingFetch } from '../utils/ssrf.js';
 import { createAbortIsolatingFetch } from '../utils/abortIsolatingFetch.js';
@@ -862,6 +863,29 @@ const updateServerPromptsCache = (serverInfo, prompts) => {
 const updateServerResourcesCache = (serverInfo, resources) => {
     serverInfo.resources = preserveListFreshness(resources, resources.map(normalizeResourceForCache));
 };
+const updateServerResourceTemplatesCache = (serverInfo, resourceTemplates) => {
+    serverInfo.resourceTemplates = Array.isArray(resourceTemplates) ? resourceTemplates : [];
+};
+// Best effort: many servers do not implement resources/templates/list.
+const refreshServerResourceTemplatesCache = async (getTarget, client, options, owner = client) => {
+    try {
+        if (!client.getServerCapabilities?.()?.resources)
+            return undefined;
+        const { resourceTemplates } = await client.listResourceTemplates({}, options || {});
+        const target = getTarget();
+        if (target && target.client === owner) {
+            updateServerResourceTemplatesCache(target, resourceTemplates);
+        }
+        return resourceTemplates;
+    }
+    catch (error) {
+        logger.debug('Failed to list resource templates for server', {
+            serverName: getTarget()?.name,
+            error: summarizeErrorForLogging(error),
+        });
+        return undefined;
+    }
+};
 // Modern HTTP has no list-changed push stream. Refresh only the lists needed
 // by the current request; TTL and in-flight work are scoped to the live client.
 const refreshModernServerLists = async (info, fields) => {
@@ -983,6 +1007,10 @@ const createUpstreamMcpClient = (name, getServerInfo, serverConfig, downstream)
                     }
                     updateServerResourcesCache(serverInfo, resources);
                     broadcastResourceListChanged();
+                    // Templates have no list-changed notification of their own.
+                    if (serverInfo.client) {
+                        void refreshServerResourceTemplatesCache(getServerInfo, serverInfo.client, serverInfo.options);
+                    }
                 },
             },
         },
@@ -2111,6 +2139,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                     });
                 }
                 if (capabilities?.resources) {
+                    void refreshServerResourceTemplatesCache(liveServerInfo, client, initRequestOptions || requestOptions);
                     client
                         .listResources({}, initRequestOptions || requestOptions)
                         .then((resources) => {
@@ -2910,6 +2939,7 @@ const ensureServerReady = async (serverInfo) => {
             }
         }
         if (capabilities?.resources) {
+            void refreshServerResourceTemplatesCache(() => serverInfo, client, requestOptions);
             try {
                 const resources = await client.listResources({}, requestOptions);
                 resourceCount = resources.resources.length;
@@ -3004,6 +3034,7 @@ export const resetServerOAuthConnection = (name) => {
     serverInfo.tools = [];
     serverInfo.prompts = [];
     serverInfo.resources = [];
+    serverInfo.resourceTemplates = undefined;
     serverInfo.oauth = undefined;
     broadcastToolListChanged();
     broadcastPromptListChanged();
@@ -4220,8 +4251,12 @@ const handleListResourceTemplatesRequestImpl = async (_, extra) => {
         if (!serverInfo.client?.listResourceTemplates) {
             return [];
         }
-        const templates = await serverInfo.client.listResourceTemplates({}, serverInfo.options || {});
+        const client = serverInfo.client;
+        const templates = await client.listResourceTemplates({}, serverInfo.options || {});
         snapshots.push(templates.resourceTemplates);
+        if (serverInfo.client === client) {
+            updateServerResourceTemplatesCache(serverInfo, templates.resourceTemplates);
+        }
         const filteredTemplates = await filterResourceTemplatesByGroup(lookupGroup, serverInfo.name, templates.resourceTemplates || [], serverConfigsByName.get(serverInfo.name));
         return appsRouteContext.enabled
             ? filteredTemplates
@@ -4234,6 +4269,60 @@ const handleListResourceTemplatesRequestImpl = async (_, extra) => {
     }
     return { resourceTemplates };
 };
+const TEMPLATE_LIST_RETRY_MS = 60000;
+const templateListFailedAt = new WeakMap();
+const getReadableResourceTemplates = async (serverInfo, uri, lookupGroup, groupServerConfig) => {
+    const serverConfig = await getServerDao().findById(serverInfo.name);
+    const groupConfig = await getGroupServerConfig(lookupGroup, serverInfo.name, groupServerConfig);
+    if (serverConfig?.resources?.[uri]?.enabled === false ||
+        (Array.isArray(groupConfig?.resources) && groupConfig.resources.length === 0)) {
+        return [];
+    }
+    const client = serverInfo.client;
+    // Modern upstreams have no list-changed stream, so honor the templates' own TTL.
+    const modern = client?.getProtocolEra?.() === 'modern';
+    if ((serverInfo.resourceTemplates === undefined || modern) &&
+        serverInfo.status === 'connected' &&
+        client &&
+        (templateListFailedAt.get(client) ?? -Infinity) < Date.now() - TEMPLATE_LIST_RETRY_MS) {
+        const refresh = async () => {
+            const listed = await refreshServerResourceTemplatesCache(() => serverInfo, client, serverInfo.options);
+            if (listed === undefined) {
+                templateListFailedAt.set(client, Date.now());
+            }
+        };
+        await (modern ? revalidateUpstreamList(client, 'templates', refresh) : refresh());
+    }
+    const templates = serverInfo.resourceTemplates;
+    if (!templates?.length) {
+        return [];
+    }
+    const enabled = templates.filter((template) => serverConfig?.resources?.[template.uriTemplate]?.enabled !== false);
+    if (!groupConfig ||
+        !Array.isArray(groupConfig.resources) ||
+        groupConfig.resources.includes(uri)) {
+        return enabled;
+    }
+    // Listing shows templates under any selected prefix; reading needs the template itself selected.
+    const selected = new Set(groupConfig.resources);
+    return enabled.filter((template) => selected.has(template.uriTemplate));
+};
+const findResourceTemplateServer = async (uri, lookupGroup, filteredServerInfos, serverConfigsByName) => {
+    for (const serverInfo of filteredServerInfos) {
+        // Idle on-demand servers keep cached templates; the read wakes them.
+        const idleOnDemand = serverInfo.config?.startOnDemand === true &&
+            serverInfo.status === 'disconnected' &&
+            !serverInfo.client;
+        if (serverInfo.status !== 'connected' && !idleOnDemand) {
+            continue;
+        }
+        const templates = await getReadableResourceTemplates(serverInfo, uri, lookupGroup, serverConfigsByName.get(serverInfo.name));
+        if (templates.some((template) => uriMatchesResourceTemplate(template.uriTemplate, uri))) {
+            return serverInfo;
+        }
+    }
+    return undefined;
+};
 const handleReadResourceRequestImpl = async (request, extra) => {
     try {
         const { uri } = request.params;
@@ -4349,7 +4438,32 @@ const handleReadResourceRequestImpl = async (request, extra) => {
             }
         }
         else {
-            throw new Error(`Resource not found: ${uri}`);
+            const templateServer = await findResourceTemplateServer(uri, lookupGroup, filteredServerInfos, serverConfigsByName);
+            if (!templateServer) {
+                throw new Error(`Resource not found: ${uri}`);
+            }
+            const releaseOnDemandRead = beginOnDemandToolCall(templateServer);
+            try {
+                if (templateServer.config?.startOnDemand) {
+                    if (!templateServer.client) {
+                        await ensureServerReady(templateServer);
+                    }
+                    templateServer.lastUsedAt = Date.now();
+                }
+                const client = templateServer.client;
+                if (!client) {
+                    throw new Error(`Resource not found: ${uri}`);
+                }
+                result = readOptions
+                    ? await client.readResource({ uri }, readOptions)
+                    : await client.readResource({ uri });
+            }
+            finally {
+                releaseOnDemandRead?.();
+            }
+            if (!result || !Array.isArray(result.contents)) {
+                throw new Error(`Failed to read resource: ${uri}`);
+            }
         }
         return appsRouteContext.enabled
             ? result
@@ -4497,6 +4611,8 @@ const createPrincipalRuntime = async (name, resolvedConfig, scope, toolsOnly = f
                 info.prompts = preserveListFreshness(prompts, prompts.map((prompt) => normalizePromptForCache(name, prompt)));
             }
             if (capabilities?.resources) {
+                // The raw client: the protected one holds the replica credential lock while listing.
+                void refreshServerResourceTemplatesCache(() => info, client, resolvedConfig.options, info.client);
                 const { resources } = await client.listResources({}, resolvedConfig.options);
                 info.resources = preserveListFreshness(resources, resources.map(normalizeResourceForCache));
             }
@@ -4755,7 +4871,17 @@ const withPrincipalServers = (handler, operation) => async (request, extra) => {
                         : { ...request, params: { ...request.params, name: `${prefix}${requestedName}` } };
             }
         }
-        return await principalServerScope.run([...scoped.values()], () => handler(resolvedRequest, extra));
+        const result = await principalServerScope.run([...scoped.values()], () => handler(resolvedRequest, extra));
+        if (operation === 'tools-list' && result.tools?.length === 0) {
+            const authorizationFailures = [...failures].filter(([, error]) => error instanceof PersonalAuthorizationRequiredError);
+            if (authorizationFailures.length) {
+                throw new ProtocolError(-32000, authorizationFailures.map(([, error]) => error.message).join(' '), {
+                    code: 'PERSONAL_AUTHORIZATION_REQUIRED',
+                    servers: authorizationFailures.map(([name]) => name),
+                });
+            }
+        }
+        return result;
     }
     finally {
         for (const release of releases)