@samanhappy/mcphub 1.0.16 → 1.0.18

package/dist/services/mcpService.js

@@ -1,6 +1,7 @@
 import os from 'os';
 import path from 'path';
 import fs from 'fs';
+import treeKill from 'tree-kill';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
@@ -26,6 +27,7 @@ import { maybeCompressToolResult } from './toolResultCompressionService.js';
 import { assertHostedToolAllowed, filterHostedTools, reserveHostedToolCall, settleHostedToolCall, } from './hostedAuthService.js';
 import { formatErrorForLogging, sanitizeStringForLogging, summarizeErrorForLogging, } from '../utils/serialization.js';
 import { MCP_APPS_CAPABILITIES, filterModelVisibleTools, hasMcpAppsCapability, isAppOnlyTool, stripMcpAppsMetadata, } from '../utils/mcpApps.js';
+import { supportsCacheRefresh, injectRefreshFlag, clearRunnerCache } from '../utils/cacheUtils.js';
 const servers = {};
 import { setupClientKeepAlive } from './keepAliveService.js';
 /**
@@ -321,6 +323,13 @@ const normalizeResourceForCache = (resource) => {
 };
 // Store all server information
 let serverInfos = [];
+// Track servers pending a cache-refresh reinstall.
+// Consumed once by createTransportFromConfig on the next reconnect.
+const pendingReinstalls = new Set();
+// Grace period after sending SIGTERM to a stdio process tree before falling back
+// to SIGKILL. Long enough to let well-behaved servers shut down cleanly, short
+// enough that a hung child does not block the container indefinitely.
+const STDIO_KILL_GRACE_PERIOD_MS = 2000;
 // Test-only helper to set serverInfos directly. Not for production use.
 export const setServerInfosForTest = (infos) => {
     serverInfos = infos;
@@ -645,7 +654,9 @@ const summarizePromptForLogging = (prompt) => {
     return summary;
 };
 export const collectPassthroughHeaders = (requestHeaders, passthroughHeaderNames) => {
-    if (!requestHeaders || !Array.isArray(passthroughHeaderNames) || passthroughHeaderNames.length === 0) {
+    if (!requestHeaders ||
+        !Array.isArray(passthroughHeaderNames) ||
+        passthroughHeaderNames.length === 0) {
         return {};
     }
     const passthroughHeaders = {};
@@ -754,7 +765,15 @@ export const createTransportFromConfig = async (name, conf) => {
             env['npm_config_registry'] = systemConfig.install.npmRegistry;
         }
         // Apply proxychains4 wrapper if proxy is configured (Linux/macOS only)
-        const { command: finalCommand, args: finalArgs } = wrapWithProxychains(name, conf.command, replaceEnvVars(conf.args), conf.proxy);
+        let resolvedArgs = replaceEnvVars(conf.args);
+        // If this server is pending a reinstall, inject cache-busting flags (uvx only).
+        // For npx, the cache directory was already cleared before reconnect.
+        if (pendingReinstalls.has(name)) {
+            resolvedArgs = injectRefreshFlag(conf.command, resolvedArgs);
+            pendingReinstalls.delete(name);
+            console.log(`[${name}] Injected cache refresh flags for reinstall`);
+        }
+        const { command: finalCommand, args: finalArgs } = wrapWithProxychains(name, conf.command, resolvedArgs, conf.proxy);
         // Create STDIO transport with potentially wrapped command
         transport = new StdioClientTransport({
             cwd: process.cwd(),
@@ -880,9 +899,18 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                 });
                 continue;
             }
-            // Check if server is already connected
-            const existingServer = existingServerInfos.find((s) => s.name === name && s.status === 'connected');
-            if (existingServer && (!serverName || serverName !== name)) {
+            // Reuse this server's existing runtime state instead of reconnecting when:
+            // - a targeted reload/reconnect (serverName) was requested for a
+            //   *different* server — preserve its current state regardless of
+            //   status. Reloading one server must not reconnect unrelated servers
+            //   (e.g. failed/disconnected ones), which would also leak their
+            //   previous stdio child processes. See #921.
+            // - a general/full initialization (no serverName) — only preserve this
+            //   server's state if it is already connected.
+            const existingServer = existingServerInfos.find((s) => s.name === name);
+            const isDifferentServer = Boolean(serverName) && serverName !== name;
+            if (existingServer &&
+                (isDifferentServer || (!serverName && existingServer.status === 'connected'))) {
                 nextServerInfos.push({
                     ...existingServer,
                     enabled: expandedConf.enabled === undefined ? true : expandedConf.enabled,
@@ -1230,10 +1258,14 @@ export const getServersInfo = async (page, limit, user) => {
                     // Don't expose codeVerifier to frontend for security
                 }
                 : undefined,
-            config: resolvedType || serverConfig?.description
+            config: resolvedType || serverConfig?.description || serverConfig?.command
                 ? {
                     ...(resolvedType ? { type: resolvedType } : {}),
                     ...(serverConfig?.description ? { description: serverConfig.description } : {}),
+                    // Expose command so the frontend can determine if reinstall is
+                    // supported (npx/uvx only). This is not a secret — it's the
+                    // runner binary name (e.g. "npx", "uvx").
+                    ...(serverConfig?.command ? { command: serverConfig.command } : {}),
                 }
                 : undefined,
         };
@@ -1289,6 +1321,42 @@ export const reconnectServer = async (serverName) => {
     await initializeClientsFromSettings(false, serverName);
     console.log(`Successfully reconnected server: ${serverName}`);
 };
+// Reinstall server: clear package cache and reconnect.
+// For npx: deletes ~/.npm/_npx before reconnect (--ignore-existing removed in npm 7+).
+// For uvx: schedules --refresh flag injection on next spawn via pendingReinstalls Set.
+export const reinstallServer = async (serverName) => {
+    console.log(`Reinstalling server: ${serverName}`);
+    const serverInfo = getServerByName(serverName);
+    if (!serverInfo) {
+        throw new Error(`Server not found: ${serverName}`);
+    }
+    const serverConfig = await getServerDao().findById(serverName);
+    if (!serverConfig) {
+        throw new Error(`Server configuration not found: ${serverName}`);
+    }
+    if (serverConfig.enabled === false) {
+        throw new Error(`Cannot reinstall a disabled server: ${serverName}`);
+    }
+    const command = serverConfig.command;
+    if (!command || !supportsCacheRefresh(command)) {
+        throw new Error(`Server "${serverName}" does not support cache refresh (command: ${command || 'none'}). Only npx and uvx servers are supported.`);
+    }
+    // Mark server as pending reinstall (consumed by createTransportFromConfig for uvx)
+    pendingReinstalls.add(serverName);
+    try {
+        // For npx, clear cache directory synchronously before reconnect.
+        // For uvx, this is a no-op — refresh is handled via --refresh flag injection.
+        await clearRunnerCache(command);
+        // Close and reconnect (will pick up pendingReinstalls flag for uvx)
+        await reconnectServer(serverName);
+        console.log(`Successfully initiated reinstall for server: ${serverName}`);
+    }
+    catch (error) {
+        // Clean up pendingReinstalls on failure to avoid stale entries
+        pendingReinstalls.delete(serverName);
+        throw error;
+    }
+};
 // Filter tools by server configuration
 const filterToolsByConfig = async (serverName, tools) => {
     const serverConfig = await getServerDao().findById(serverName);
@@ -1323,6 +1391,11 @@ export const removeServer = async (name) => {
     if (!result) {
         return { success: false, message: 'Failed to remove server' };
     }
+    // Close the client and terminate the underlying child process tree BEFORE
+    // dropping the serverInfos reference. Without this, a stdio child launched
+    // via npx / npm exec outlives the request and becomes an unkillable orphan
+    // that leaks memory until the container is restarted.
+    closeServer(name);
     try {
         await removeServerToolEmbeddings(name);
     }
@@ -1373,7 +1446,10 @@ function checkAuthError(result) {
                 // Ignore JSON parse errors and continue
                 return;
             }
-            if (errorContent.code === 401) {
+            // JSON.parse can yield null or a primitive (e.g. text "null", "42",
+            // "true") — only an object payload can carry an auth error code, so guard
+            // the property access to avoid crashing on non-object results.
+            if (errorContent && typeof errorContent === 'object' && errorContent.code === 401) {
                 throw new Error('Error POSTing to endpoint (HTTP 401 Unauthorized)');
             }
         }
@@ -1389,10 +1465,76 @@ function closeServer(name) {
             serverInfo.keepAliveIntervalId = undefined;
             console.log(`Cleared keep-alive interval for server: ${serverInfo.name}`);
         }
+        // Capture the child PID via duck-typing. `instanceof StdioClientTransport`
+        // is unreliable under pnpm's "dual package hazard" — a different copy of
+        // @modelcontextprotocol/sdk in node_modules makes the check return false
+        // even for genuine stdio transports. The `pid` getter is the SDK's public
+        // contract, so checking for it is both safer and version-agnostic.
+        const candidateTransport = serverInfo.transport;
+        const stdioPid = typeof candidateTransport.pid === 'number' ? candidateTransport.pid : null;
         serverInfo.client.close();
         serverInfo.transport.close();
+        if (stdioPid) {
+            killStdioProcessTree(name, stdioPid);
+        }
         console.log(`Closed client and transport for server: ${serverInfo.name}`);
-        // TODO kill process
+    }
+}
+// Kill the entire process tree of a stdio transport's child process.
+//
+// transport.close() only sends SIGTERM to the direct child. When the server is
+// launched through a wrapper like `npx` / `npm exec`, the wrapper does not
+// forward signals to its descendants, so the real server process is left
+// running as an orphan. Walk the whole tree and force-kill it.
+function killStdioProcessTree(name, pid) {
+    const safeTreeKill = (signal) => {
+        try {
+            treeKill(pid, signal, (err) => {
+                if (err) {
+                    // ESRCH (no such process) is expected when the process already exited
+                    // — treat as success. Anything else is worth a warning.
+                    const code = err.code;
+                    if (code !== 'ESRCH') {
+                        // Pass the user-controlled `name` as a separate argument so a
+                        // server named e.g. "%s" cannot inject format specifiers into the
+                        // log line (CodeQL: use-of-externally-controlled-format-string).
+                        console.warn('Failed to send signal to process tree', {
+                            serverName: name,
+                            pid,
+                            signal,
+                            err,
+                        });
+                    }
+                }
+            });
+        }
+        catch (err) {
+            console.warn('Failed to send signal to process tree', {
+                serverName: name,
+                pid,
+                signal,
+                err,
+            });
+        }
+    };
+    safeTreeKill('SIGTERM');
+    setTimeout(() => {
+        if (!isProcessAlive(pid)) {
+            return;
+        }
+        safeTreeKill('SIGKILL');
+    }, STDIO_KILL_GRACE_PERIOD_MS);
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM means the process exists but we don't have permission to signal
+        // it — count it as alive so the SIGKILL fallback still fires. Any other
+        // error (typically ESRCH) means the process is gone.
+        return err.code === 'EPERM';
     }
 }
 // Toggle server enabled status
@@ -1464,6 +1606,31 @@ const normalizeToolNameForServer = (serverName, toolName) => {
     const prefix = `${serverName}${getNameSeparator()}`;
     return toolName.startsWith(prefix) ? toolName.substring(prefix.length) : toolName;
 };
+const getGroupLookupName = (group) => {
+    if (group?.startsWith('$smart/')) {
+        return group.substring(7) || undefined;
+    }
+    return group;
+};
+const getExposedServerName = (serverName, serverConfig) => {
+    return serverConfig?.alias?.trim() || serverName;
+};
+const replacePrefixedServerName = (name, fromServerName, toServerName) => {
+    if (fromServerName === toServerName) {
+        return name;
+    }
+    const separator = getNameSeparator();
+    const prefix = `${fromServerName}${separator}`;
+    return name.startsWith(prefix)
+        ? `${toServerName}${separator}${name.substring(prefix.length)}`
+        : name;
+};
+const projectNameForGroup = (name, serverName, serverConfig) => {
+    return replacePrefixedServerName(name, serverName, getExposedServerName(serverName, serverConfig));
+};
+const resolveNameFromGroup = (name, serverName, serverConfig) => {
+    return replacePrefixedServerName(name, getExposedServerName(serverName, serverConfig), serverName);
+};
 const findToolOnServer = (serverInfo, toolName, allowRawName) => {
     return serverInfo.tools.find((tool) => tool.name === toolName ||
         (allowRawName && normalizeToolNameForServer(serverInfo.name, tool.name) === toolName));
@@ -1473,7 +1640,55 @@ const assertToolAvailableForRoute = (tool, appsRouteContext) => {
         throw new Error(`Tool '${tool.name}' is only available to MCP Apps`);
     }
 };
-const projectToolForDownstream = (serverName, tool, appsRouteContext) => {
+const resolveToolInGroup = async (group, toolName, allowRawName) => {
+    const lookupGroup = getGroupLookupName(group);
+    if (!lookupGroup) {
+        return undefined;
+    }
+    const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(lookupGroup);
+    for (const serverInfo of filteredServerInfos) {
+        if (serverInfo.status !== 'connected' || serverInfo.enabled === false) {
+            continue;
+        }
+        const serverConfig = serverConfigsByName.get(serverInfo.name);
+        const internalToolName = resolveNameFromGroup(toolName, serverInfo.name, serverConfig);
+        const tool = findToolOnServer(serverInfo, internalToolName, allowRawName);
+        if (!tool) {
+            continue;
+        }
+        const filteredTools = await filterToolsByGroup(lookupGroup, serverInfo.name, [tool], serverConfig);
+        if (filteredTools.length === 0) {
+            continue;
+        }
+        return { serverInfo, toolName: internalToolName, tool };
+    }
+    return undefined;
+};
+async function resolvePromptInGroup(group, promptName) {
+    const lookupGroup = getGroupLookupName(group);
+    if (!lookupGroup) {
+        return undefined;
+    }
+    const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(lookupGroup);
+    for (const serverInfo of filteredServerInfos) {
+        if (serverInfo.status !== 'connected' || serverInfo.enabled === false) {
+            continue;
+        }
+        const serverConfig = serverConfigsByName.get(serverInfo.name);
+        const internalPromptName = resolveNameFromGroup(promptName, serverInfo.name, serverConfig);
+        const prompt = serverInfo.prompts.find((item) => item.name === internalPromptName);
+        if (!prompt) {
+            continue;
+        }
+        const filteredPrompts = await filterPromptsByGroup(lookupGroup, serverInfo.name, [prompt], serverConfig);
+        if (filteredPrompts.length === 0) {
+            continue;
+        }
+        return { serverInfo, promptName: internalPromptName };
+    }
+    return undefined;
+}
+const projectToolForDownstream = (serverName, tool, appsRouteContext, serverConfig) => {
     if (!appsRouteContext.enabled && isAppOnlyTool(tool)) {
         return undefined;
     }
@@ -1482,7 +1697,7 @@ const projectToolForDownstream = (serverName, tool, appsRouteContext) => {
         ...projectedTool,
         name: appsRouteContext.enabled
             ? normalizeToolNameForServer(serverName, projectedTool.name)
-            : projectedTool.name,
+            : projectNameForGroup(projectedTool.name, serverName, serverConfig),
     };
 };
 export const handleListToolsRequest = async (_, extra) => {
@@ -1499,10 +1714,11 @@ export const handleListToolsRequest = async (_, extra) => {
     const allTools = [];
     for (const serverInfo of filteredServerInfos) {
         if (serverInfo.tools && serverInfo.tools.length > 0) {
+            const groupServerConfig = serverConfigsByName.get(serverInfo.name);
             // Filter tools based on server configuration
             let tools = await filterToolsByConfig(serverInfo.name, serverInfo.tools);
             // If this is a group request, apply group-level tool filtering
-            tools = await filterToolsByGroup(group, serverInfo.name, tools, serverConfigsByName.get(serverInfo.name));
+            tools = await filterToolsByGroup(group, serverInfo.name, tools, groupServerConfig);
             // Apply custom descriptions from server configuration
             const serverConfig = await getServerDao().findById(serverInfo.name);
             const toolsWithCustomDescriptions = tools.map((tool) => {
@@ -1513,7 +1729,7 @@ export const handleListToolsRequest = async (_, extra) => {
                 };
             });
             allTools.push(...toolsWithCustomDescriptions.flatMap((tool) => {
-                const projectedTool = projectToolForDownstream(serverInfo.name, tool, appsRouteContext);
+                const projectedTool = projectToolForDownstream(serverInfo.name, tool, appsRouteContext, groupServerConfig);
                 return projectedTool ? [projectedTool] : [];
             }));
         }
@@ -1574,12 +1790,22 @@ export const handleCallToolRequest = async (request, extra) => {
             }
             const { arguments: toolArgs } = request.params.arguments || {};
             let targetServerInfo;
+            let targetToolName = toolName;
+            let targetTool;
             if (appsRouteContext.enabled) {
                 targetServerInfo = appsRouteContext.serverInfo;
             }
             else if (extra && extra.server) {
                 targetServerInfo = getServerByName(extra.server);
             }
+            else if (group) {
+                const groupTool = await resolveToolInGroup(group, toolName, appsRouteContext.enabled);
+                if (groupTool) {
+                    targetServerInfo = groupTool.serverInfo;
+                    targetToolName = groupTool.toolName;
+                    targetTool = groupTool.tool;
+                }
+            }
             else {
                 // Find the first server that has this tool
                 targetServerInfo = serverInfos.find((serverInfo) => serverInfo.status === 'connected' &&
@@ -1590,7 +1816,7 @@ export const handleCallToolRequest = async (request, extra) => {
                 throw new Error(`No available servers found with tool: ${toolName}`);
             }
             // Check if the tool exists on the server
-            const tool = findToolOnServer(targetServerInfo, toolName, appsRouteContext.enabled);
+            const tool = targetTool ?? findToolOnServer(targetServerInfo, targetToolName, appsRouteContext.enabled);
             if (!tool) {
                 throw new Error(`Tool '${toolName}' not found on server '${targetServerInfo.name}'`);
             }
@@ -1602,12 +1828,12 @@ export const handleCallToolRequest = async (request, extra) => {
                 // Use toolArgs if it has properties, otherwise fallback to request.params.arguments
                 const finalArgs = toolArgs && typeof toolArgs === 'object' ? toolArgs : {};
                 console.log('Invoking OpenAPI tool', {
-                    toolName,
+                    toolName: targetToolName,
                     serverName: targetServerInfo.name,
                     arguments: summarizeArgumentsForLogging(finalArgs),
                 });
                 // Remove server prefix from tool name if present
-                const cleanToolName = normalizeToolNameForServer(targetServerInfo.name, toolName);
+                const cleanToolName = normalizeToolNameForServer(targetServerInfo.name, targetToolName);
                 // Extract passthrough headers from extra or request context
                 let passthroughHeaders;
                 let requestHeaders = null;
@@ -1680,11 +1906,11 @@ export const handleCallToolRequest = async (request, extra) => {
             // Use toolArgs if it has properties, otherwise fallback to request.params.arguments
             const finalArgs = toolArgs && typeof toolArgs === 'object' ? toolArgs : {};
             console.log('Invoking tool', {
-                toolName,
+                toolName: targetToolName,
                 serverName: targetServerInfo.name,
                 arguments: summarizeArgumentsForLogging(finalArgs),
             });
-            const cleanToolName = normalizeToolNameForServer(targetServerInfo.name, toolName);
+            const cleanToolName = normalizeToolNameForServer(targetServerInfo.name, targetToolName);
             await reserveHostedIfNeeded(targetServerInfo.name, cleanToolName);
             const result = await callToolWithReconnect(targetServerInfo, {
                 name: cleanToolName,
@@ -1723,12 +1949,17 @@ export const handleCallToolRequest = async (request, extra) => {
             });
         }
         // Regular tool handling
+        const groupTool = !appsRouteContext.enabled && group
+            ? await resolveToolInGroup(group, request.params.name, appsRouteContext.enabled)
+            : undefined;
         const serverInfo = appsRouteContext.enabled
             ? appsRouteContext.serverInfo
-            : getServerByTool(request.params.name);
-        const tool = serverInfo
-            ? findToolOnServer(serverInfo, request.params.name, appsRouteContext.enabled)
-            : undefined;
+            : (groupTool?.serverInfo ?? (group ? undefined : getServerByTool(request.params.name)));
+        const routeToolName = groupTool?.toolName ?? request.params.name;
+        const tool = groupTool?.tool ??
+            (serverInfo
+                ? findToolOnServer(serverInfo, routeToolName, appsRouteContext.enabled)
+                : undefined);
         if (!serverInfo || !tool) {
             throw new Error(`Server not found: ${request.params.name}`);
         }
@@ -1738,7 +1969,7 @@ export const handleCallToolRequest = async (request, extra) => {
             // For OpenAPI servers, use the OpenAPI client
             const openApiClient = serverInfo.openApiClient;
             // Remove server prefix from tool name if present
-            const cleanToolName = normalizeToolNameForServer(serverInfo.name, request.params.name);
+            const cleanToolName = normalizeToolNameForServer(serverInfo.name, routeToolName);
             console.log('Invoking OpenAPI tool', {
                 toolName: cleanToolName,
                 serverName: serverInfo.name,
@@ -1814,7 +2045,7 @@ export const handleCallToolRequest = async (request, extra) => {
         if (!client) {
             throw new Error(`Client not found for server: ${serverInfo.name}`);
         }
-        const cleanToolName = normalizeToolNameForServer(serverInfo.name, request.params.name);
+        const cleanToolName = normalizeToolNameForServer(serverInfo.name, routeToolName);
         await reserveHostedIfNeeded(serverInfo.name, cleanToolName);
         const result = await callToolWithReconnect(serverInfo, { ...request.params, name: cleanToolName }, serverInfo.options || {});
         await settleHostedIfNeeded({
@@ -1890,6 +2121,8 @@ export const handleCallToolRequest = async (request, extra) => {
 export const handleGetPromptRequest = async (request, extra) => {
     try {
         const { name, arguments: promptArgs } = request.params;
+        const sessionId = extra?.sessionId || '';
+        const group = extra?.group || getGroup(sessionId) || undefined;
         // Check built-in prompts first
         const builtinPrompt = await getBuiltinPromptDao().findByName(name);
         if (builtinPrompt && builtinPrompt.enabled !== false) {
@@ -1910,9 +2143,17 @@ export const handleGetPromptRequest = async (request, extra) => {
             };
         }
         let server;
+        let promptNameForServer = name;
         if (extra && extra.server) {
             server = getServerByName(extra.server);
         }
+        else if (group) {
+            const groupPrompt = await resolvePromptInGroup(group, name);
+            if (groupPrompt) {
+                server = groupPrompt.serverInfo;
+                promptNameForServer = groupPrompt.promptName;
+            }
+        }
         else {
             // Find the first server that has this prompt
             server = serverInfos.find((serverInfo) => serverInfo.status === 'connected' &&
@@ -1925,7 +2166,9 @@ export const handleGetPromptRequest = async (request, extra) => {
         // Remove server prefix from prompt name if present
         const separator = getNameSeparator();
         const prefix = `${server.name}${separator}`;
-        const cleanPromptName = name.startsWith(prefix) ? name.substring(prefix.length) : name;
+        const cleanPromptName = promptNameForServer.startsWith(prefix)
+            ? promptNameForServer.substring(prefix.length)
+            : promptNameForServer;
         const promptParams = {
             name: cleanPromptName || '',
             arguments: promptArgs,
@@ -1971,6 +2214,7 @@ export const handleListPromptsRequest = async (_, extra) => {
     const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(group);
     for (const serverInfo of filteredServerInfos) {
         if (serverInfo.prompts && serverInfo.prompts.length > 0) {
+            const groupServerConfig = serverConfigsByName.get(serverInfo.name);
             // Filter prompts based on server configuration
             const serverConfig = await getServerDao().findById(serverInfo.name);
             let enabledPrompts = serverInfo.prompts;
@@ -1981,12 +2225,13 @@ export const handleListPromptsRequest = async (_, extra) => {
                     return promptConfig?.enabled !== false;
                 });
             }
-            enabledPrompts = await filterPromptsByGroup(group, serverInfo.name, enabledPrompts, serverConfigsByName.get(serverInfo.name));
+            enabledPrompts = await filterPromptsByGroup(group, serverInfo.name, enabledPrompts, groupServerConfig);
             // Apply custom descriptions from server configuration
             const promptsWithCustomDescriptions = enabledPrompts.map((prompt) => {
                 const promptConfig = serverConfig?.prompts?.[prompt.name];
                 return normalizePromptForList({
                     ...prompt,
+                    name: projectNameForGroup(prompt.name, serverInfo.name, groupServerConfig),
                     description: promptConfig?.description || prompt.description, // Use custom description if available
                 });
             });