@samanhappy/mcphub 1.1.13 → 1.1.15

package/dist/services/mcpService.js

@@ -1,3 +1,4 @@
+import { getToolPolicy } from './toolPolicyService.js';
 import { projectGroupToolName, assertValidGroupToolNames } from '../utils/groupToolNames.js';
 import { isSafePassthroughHeader } from '../utils/passthroughHeaders.js';
 import { observeToolCall, setMetricsServer } from './metricsService.js';
@@ -38,6 +39,7 @@ import config from '../config/index.js';
 import { validateMaxBufferSize } from '../utils/stdioOptions.js';
 import { validateServerName } from '../utils/serverNameValidation.js';
 import { getGroup } from './sseService.js';
+import { mcpEventBus } from './mcpEventBus.js';
 import { getServerConfigInGroup, normalizeGroupServers } from './groupService.js';
 import { removeServerToolEmbeddings, removeToolEmbeddings, saveToolsAsVectorEmbeddings, } from './vectorSearchService.js';
 import { OpenAPIClient } from '../clients/openapi.js';
@@ -429,6 +431,7 @@ export const notifyToolChanged = async (name, options) => {
     broadcastToolListChanged();
 };
 const broadcastListChanged = (listType, sendNotification) => {
+    mcpEventBus.publish({ kind: `${listType}s_list_changed` });
     Object.values(servers).forEach((server) => {
         sendNotification(server)
             .then(() => {
@@ -448,18 +451,20 @@ export const broadcastResourceListChanged = () => {
 export const broadcastPromptListChanged = () => {
     broadcastListChanged('prompt', (server) => server.sendPromptListChanged());
 };
-export const updateServerInfoVisibility = (serverName, visibility, sharedWithUsers) => {
+export const updateServerInfoVisibility = (serverName, visibility, sharedWithUsers, sharedWithUserGroups) => {
     const serverInfo = getServerByName(serverName);
     if (!serverInfo) {
         return;
     }
     serverInfo.visibility = visibility;
     serverInfo.sharedWithUsers = sharedWithUsers;
+    serverInfo.sharedWithUserGroups = sharedWithUserGroups;
     if (serverInfo.config) {
         serverInfo.config = {
             ...serverInfo.config,
             visibility,
             sharedWithUsers,
+            sharedWithUserGroups,
         };
     }
 };
@@ -729,7 +734,16 @@ const principalServerScope = new AsyncLocalStorage();
 // Header-dependent discovery must never publish descriptors or embeddings globally.
 const requestDiscoveryInfos = new WeakSet();
 const getVisibleServerInfos = () => {
-    return getDataService().filterData(principalServerScope.getStore() ?? serverInfos);
+    const visible = getDataService().filterData(principalServerScope.getStore() ?? serverInfos);
+    // A system key with accessType 'exclude' hides its excluded servers (and the
+    // members of excluded groups, already expanded by the auth layer) from every
+    // listing, call resolution and smart-routing surface that reads this list.
+    const excludedServers = RequestContextService.getInstance().getBearerKeyExclusions();
+    if (!excludedServers || excludedServers.length === 0) {
+        return visible;
+    }
+    const excluded = new Set(excludedServers);
+    return visible.filter((serverInfo) => !excluded.has(serverInfo.name));
 };
 const getVisibleServerByName = (name) => {
     return getVisibleServerInfos().find((serverInfo) => serverInfo.name === name);
@@ -1698,6 +1712,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                     name,
                     owner: expandedConf.owner,
                     visibility: expandedConf.visibility,
+                    sharedWithUserGroups: expandedConf.sharedWithUserGroups,
                     sharedWithUsers: expandedConf.sharedWithUsers,
                     status: 'disconnected',
                     error: null,
@@ -1715,6 +1730,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                     name,
                     owner: expandedConf.owner,
                     visibility: expandedConf.visibility,
+                    sharedWithUserGroups: expandedConf.sharedWithUserGroups,
                     sharedWithUsers: expandedConf.sharedWithUsers,
                     enabled: true,
                     status: 'disconnected',
@@ -1749,6 +1765,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                 Object.assign(onDemandInfo, {
                     owner: expandedConf.owner,
                     visibility: expandedConf.visibility,
+                    sharedWithUserGroups: expandedConf.sharedWithUserGroups,
                     sharedWithUsers: expandedConf.sharedWithUsers,
                     enabled: true,
                     config: expandedConf,
@@ -1786,6 +1803,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                 Object.assign(existingServer, {
                     owner: expandedConf.owner,
                     visibility: expandedConf.visibility,
+                    sharedWithUserGroups: expandedConf.sharedWithUserGroups,
                     sharedWithUsers: expandedConf.sharedWithUsers,
                     enabled: expandedConf.enabled === undefined ? true : expandedConf.enabled,
                 });
@@ -1811,6 +1829,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                         name,
                         owner: expandedConf.owner,
                         visibility: expandedConf.visibility,
+                        sharedWithUserGroups: expandedConf.sharedWithUserGroups,
                         sharedWithUsers: expandedConf.sharedWithUsers,
                         status: 'disconnected',
                         error: 'Missing OpenAPI specification URL or schema',
@@ -1826,6 +1845,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                     name,
                     owner: expandedConf.owner,
                     visibility: expandedConf.visibility,
+                    sharedWithUserGroups: expandedConf.sharedWithUserGroups,
                     sharedWithUsers: expandedConf.sharedWithUsers,
                     status: 'connecting',
                     error: null,
@@ -1919,6 +1939,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                         name,
                         owner: expandedConf.owner,
                         visibility: expandedConf.visibility,
+                        sharedWithUserGroups: expandedConf.sharedWithUserGroups,
                         sharedWithUsers: expandedConf.sharedWithUsers,
                         status: 'disconnected',
                         error: `Failed to create transport: ${formatErrorForLogging(error)}`,
@@ -1953,6 +1974,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                 name,
                 owner: expandedConf.owner,
                 visibility: expandedConf.visibility,
+                sharedWithUserGroups: expandedConf.sharedWithUserGroups,
                 sharedWithUsers: expandedConf.sharedWithUsers,
                 status: 'connecting',
                 recovery: existingServer?.recovery,
@@ -2202,6 +2224,7 @@ export const getServersInfo = async (page, limit, user) => {
                 name: server.name,
                 owner: server.owner,
                 visibility: server.visibility,
+                sharedWithUserGroups: server.sharedWithUserGroups,
                 sharedWithUsers: server.sharedWithUsers,
                 // Newly created servers that are enabled should appear as "connecting"
                 // until the MCP client initialization completes. Disabled servers remain
@@ -2332,6 +2355,7 @@ export const getServersInfo = async (page, limit, user) => {
                 : undefined,
             config: resolvedType || serverConfig?.description || serverConfig?.command
                 ? {
+                    ...(serverConfig?.id ? { id: serverConfig.id } : {}),
                     ...(resolvedType ? { type: resolvedType } : {}),
                     ...(hasPersonalAuthentication(serverConfig)
                         ? { credentialTemplate: validateCredentialTemplate(serverConfig) }
@@ -3455,12 +3479,14 @@ const handleCallToolRequestImpl = async (request, extra) => {
     const group = getMcpRequestGroup(extra);
     const username = requestContextService.getUsernameContext() ||
         extra?.username ||
+        UserContextService.getInstance().getCurrentUser()?.username ||
         (requestContextService.getKeyKindContext() === 'system' ? 'system' : undefined) ||
         undefined;
     let appsRouteContext;
     const keyId = bearerKeyContext.keyId || extra?.keyId || undefined;
     const keyName = bearerKeyContext.keyName || extra?.keyName || undefined;
     const sourceIp = requestContextService.getRequestContext()?.remoteAddress || undefined;
+    let policyAudit;
     let hostedReservation = null;
     let releaseOnDemandToolCall;
     let clientStateLease;
@@ -3471,6 +3497,19 @@ const handleCallToolRequestImpl = async (request, extra) => {
         return clientStateLease.id;
     };
     const reserveHostedIfNeeded = async (serverName, toolName) => {
+        const policy = await getToolPolicy(group);
+        const decision = policy.authorize(serverName, toolName);
+        policyAudit = { ...decision, serverId: policy.serverId(serverName), groupId: policy.groupId };
+        logger.log('Tool policy decision', {
+            username,
+            callerId: keyId,
+            server: serverName,
+            tool: toolName,
+            ...policyAudit,
+        });
+        if (decision.decision === 'deny') {
+            throw new ToolUnavailableError(`Tool not available: ${toolName}`, decision.reason);
+        }
         const hostedAuth = requestContextService.getHostedAuthContext();
         assertHostedToolAllowed(hostedAuth, serverName, toolName);
         hostedReservation = await reserveHostedToolCall(hostedAuth, serverName, toolName);
@@ -3624,6 +3663,7 @@ const handleCallToolRequestImpl = async (request, extra) => {
                 // Log successful activity
                 const duration = Date.now() - startTime;
                 await activityLogger.logToolCall({
+                    policy: policyAudit,
                     server: targetServerInfo.name,
                     tool: cleanToolName,
                     duration,
@@ -3698,6 +3738,7 @@ const handleCallToolRequestImpl = async (request, extra) => {
             // Log successful activity
             const duration = Date.now() - startTime;
             await activityLogger.logToolCall({
+                policy: policyAudit,
                 server: targetServerInfo.name,
                 tool: cleanToolName,
                 duration,
@@ -3808,6 +3849,7 @@ const handleCallToolRequestImpl = async (request, extra) => {
             // Log successful activity
             const duration = Date.now() - startTime;
             await activityLogger.logToolCall({
+                policy: policyAudit,
                 server: serverInfo.name,
                 tool: cleanToolName,
                 duration,
@@ -3866,6 +3908,7 @@ const handleCallToolRequestImpl = async (request, extra) => {
         // Log successful activity
         const duration = Date.now() - startTime;
         await activityLogger.logToolCall({
+            policy: policyAudit,
             server: serverInfo.name,
             tool: cleanToolName,
             duration,
@@ -3898,7 +3941,7 @@ const handleCallToolRequestImpl = async (request, extra) => {
             callerLabel: keyName,
             toolName: activityToolName,
             ...summarizeErrorForLogging(error),
-            ...(unavailable ? { reason: unavailable.reason } : {}),
+            ...(unavailable ? { decision: 'deny', reason: unavailable.reason } : {}),
         });
         // Log error activity
         const duration = Date.now() - startTime;
@@ -3911,6 +3954,7 @@ const handleCallToolRequestImpl = async (request, extra) => {
             getServerByTool(activityToolName);
         const cleanToolName = stripToolServerPrefix(activityToolName, serverInfo?.name);
         await activityLogger.logToolCall({
+            policy: policyAudit ?? (unavailable ? { decision: 'deny', reason: unavailable.reason } : undefined),
             server: serverInfo?.name || 'unknown',
             tool: cleanToolName,
             duration,
@@ -4336,6 +4380,7 @@ const createPrincipalRuntime = async (name, resolvedConfig, scope, toolsOnly = f
         name,
         owner: resolvedConfig.owner,
         visibility: resolvedConfig.visibility,
+        sharedWithUserGroups: resolvedConfig.sharedWithUserGroups,
         sharedWithUsers: resolvedConfig.sharedWithUsers,
         enabled: true,
         config: resolvedConfig,
@@ -4691,6 +4736,7 @@ const listProjectionInputs = async (group, field) => {
             enabled: info.enabled,
             owner: info.owner,
             visibility: info.visibility,
+            sharedWithUserGroups: info.sharedWithUserGroups,
             sharedWithUsers: info.sharedWithUsers,
             config: info.config,
         })),
@@ -4746,9 +4792,109 @@ const withCacheHints = (handler, passthroughTtl = false, listField) => async (re
     // and capabilities. Shared caches must not reuse the gateway result across users.
     return { ...result, ttlMs, cacheScope: 'private' };
 };
-export const handleListToolsRequest = withPrincipalServers(withModernLists(withCacheHints(handleListToolsRequestImpl, false, 'tools'), ['tools']), 'tools-list');
+const listToolsWithPrincipal = withPrincipalServers(withModernLists(withCacheHints(handleListToolsRequestImpl, false, 'tools'), ['tools']), 'tools-list');
 const callToolWithPrincipal = withPrincipalServers(withModernLists(handleCallToolRequestImpl, ['tools']), 'tool');
-export const handleCallToolRequest = (request, extra) => observeToolCall(() => callToolWithPrincipal(request, extra));
+// Run before personal-runtime acquisition: rejected targets must not resolve credentials.
+const withToolPolicy = async (handler, request, extra, invocation) => {
+    const group = getMcpRequestGroup(extra);
+    const policy = await getToolPolicy(group);
+    if (!policy.active)
+        return handler(request, extra);
+    const { filteredServerInfos: candidates, serverConfigsByName } = await getFilteredServerInfosForGroup(getGroupLookupName(group));
+    const username = UserContextService.getInstance().getCurrentUser()?.username;
+    const preflightInfo = (info) => {
+        const tools = username ? principalRuntimes.peekTools(info.name, username) : undefined;
+        return tools ? { ...info, tools } : info;
+    };
+    const lookup = getGroupLookupName(group);
+    const direct = !!lookup && !isSmartRoutingGroup(group) && !(await findRouteGroup(lookup));
+    const upstreamOwnsName = direct &&
+        candidates.map(preflightInfo).some((info) => info.tools.length
+            ? info.tools.some((tool) => normalizeToolNameForServer(info.name, tool.name) === request.params?.name)
+            : // Until discovery disambiguates a raw meta-name, require it to be authorized too.
+                hasPersonalAuthentication(info.config) &&
+                    policy.authorize(info.name, request.params?.name).decision === 'deny');
+    const wrapper = !upstreamOwnsName && ['call_tool', 'describe_tool'].includes(request.params?.name);
+    const requested = wrapper ? request.params.arguments?.toolName : request.params?.name;
+    const targetCall = invocation && (upstreamOwnsName || request.params?.name !== 'search_tools');
+    let denied;
+    const eligible = candidates.filter((info) => {
+        if (extra?.server && info.name !== extra.server)
+            return false;
+        const config = serverConfigsByName.get(info.name);
+        const internal = typeof requested === 'string'
+            ? config?.preserveToolNames
+                ? `${info.name}${getNameSeparator()}${requested}`
+                : resolveNameFromGroup(requested, info.name, config)
+            : undefined;
+        const known = internal
+            ? findToolOnServer(preflightInfo(info), internal, direct || !!extra?.server || candidates.length === 1, direct)
+            : undefined;
+        const prefix = `${info.name}${getNameSeparator()}`;
+        const tool = known
+            ? normalizeToolNameForServer(info.name, known.name)
+            : internal?.startsWith(prefix)
+                ? internal.slice(prefix.length)
+                : direct || extra?.server || candidates.length === 1 || config?.preserveToolNames
+                    ? internal
+                    : undefined;
+        if (targetCall && !tool)
+            return false;
+        let decision = policy.authorize(info.name, targetCall ? tool : undefined, !targetCall);
+        if (targetCall &&
+            direct &&
+            !preflightInfo(info).tools.length &&
+            hasPersonalAuthentication(info.config)) {
+            // Without a catalog, both raw and prefixed/wrapper interpretations must be allowed.
+            for (const alternative of [requested, request.params?.name]) {
+                const alternativeDecision = policy.authorize(info.name, alternative);
+                if (alternativeDecision.decision === 'deny')
+                    decision = alternativeDecision;
+            }
+        }
+        if (decision.decision === 'deny') {
+            denied = {
+                server: info,
+                tool: tool || requested || 'unknown',
+                decision: { ...decision, serverId: policy.serverId(info.name), groupId: policy.groupId },
+            };
+            return false;
+        }
+        return true;
+    });
+    if (targetCall && !eligible.length && denied) {
+        const context = RequestContextService.getInstance();
+        const { keyId, keyName } = context.getBearerKeyContext();
+        const username = UserContextService.getInstance().getCurrentUser()?.username;
+        logger.log('Tool policy decision', {
+            username,
+            callerId: keyId,
+            server: denied.server.name,
+            tool: denied.tool,
+            ...denied.decision,
+        });
+        await getActivityLoggingService().logToolCall({
+            server: denied.server.name,
+            tool: denied.tool,
+            duration: 0,
+            status: 'error',
+            username,
+            keyId,
+            keyName,
+            group,
+            policy: denied.decision,
+            sourceIp: context.getRequestContext()?.remoteAddress,
+            hasCredentialTemplate: hasPersonalAuthentication(denied.server.config),
+        });
+        return {
+            content: [{ type: 'text', text: `Error: Tool not available: ${requested}` }],
+            isError: true,
+        };
+    }
+    return principalServerScope.run(eligible, () => handler(request, extra));
+};
+export const handleListToolsRequest = (request, extra) => withToolPolicy(listToolsWithPrincipal, request, extra, false);
+export const handleCallToolRequest = (request, extra) => observeToolCall(() => withToolPolicy(callToolWithPrincipal, request, extra, true));
 export const handleGetPromptRequest = withPrincipalServers(withModernLists(handleGetPromptRequestImpl, ['prompts']), 'prompt');
 export const handleListPromptsRequest = withPrincipalServers(withModernLists(withCacheHints(handleListPromptsRequestImpl, false, 'prompts'), ['prompts']), 'list');
 export const handleListResourcesRequest = withPrincipalServers(withModernLists(withCacheHints(handleListResourcesRequestImpl, false, 'resources'), [
@@ -4853,7 +4999,8 @@ async function filterToolsByGroup(group, serverName, tools, serverConfig) {
         }
     }
     const hostedAuth = RequestContextService.getInstance().getHostedAuthContext();
-    return filterHostedTools(hostedAuth, serverName, tools, getNameSeparator());
+    const policy = await getToolPolicy(getMcpRequestGroup() || group);
+    return policy.filterTools(serverName, filterHostedTools(hostedAuth, serverName, tools, getNameSeparator()));
 }
 const normalizePromptNameForGroup = (serverName, promptName) => {
     const prefix = `${serverName}${getNameSeparator()}`;