@samanhappy/mcphub 1.0.36 → 1.0.38

package/dist/services/mcpService.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { canAccessGroupRoute } from '../utils/groupAccess.js';
 import { PrincipalRuntimeService } from './principalRuntimeService.js';
 import { UserContextService } from './userContextService.js';
 import { deleteCredentialBindings, missingCredentialError } from './credentialBindingService.js';
@@ -524,6 +525,82 @@ const normalizeResourceForCache = (resource) => {
 };
 // Store all server information
 let serverInfos = [];
+/**
+ * How many upstream connections an initialization pass may open at once.
+ * Unset, empty or `0` keeps the previous behaviour of connecting every enabled
+ * server in parallel. Read per pass so a restart is enough to change it.
+ */
+const resolveStartupConcurrency = () => {
+    const raw = process.env.STARTUP_CONNECT_CONCURRENCY?.trim();
+    if (!raw) {
+        return 0;
+    }
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        logger.warn(`Ignoring invalid STARTUP_CONNECT_CONCURRENCY="${raw}"; expected a non-negative integer. Connecting without a limit.`);
+        return 0;
+    }
+    return parsed;
+};
+/**
+ * Rejection reason for a queued connection that was dropped before it started,
+ * because the server it belonged to was disabled, removed or superseded while
+ * it waited for a slot. Not a connection failure: nothing was spawned and there
+ * is nothing wrong with the server, so callers report it as a cancellation
+ * rather than marking the server as failed.
+ */
+class QueuedConnectCancelledError extends Error {
+    constructor() {
+        super('Queued connection was cancelled before it started');
+        this.name = 'QueuedConnectCancelledError';
+    }
+}
+/**
+ * Defers the *invocation* of a connect rather than wrapping its promise, so a
+ * server waiting for a slot has not started its request yet and its timeout
+ * budget is not spent queueing. A limit of 0 runs everything immediately.
+ *
+ * Because work waits here, what the operator wants can change while it waits -
+ * a queued server may be disabled, removed or replaced by a later pass. The
+ * `isStillWanted` guard is therefore evaluated when the slot is granted, not
+ * when the work is queued; a queued entry that is no longer wanted is cancelled
+ * and its slot handed straight to the next in line.
+ */
+const createConnectGate = (limit) => {
+    if (limit <= 0) {
+        // Nothing queues, so nothing can go stale while it waits.
+        return { run: (start) => start() };
+    }
+    let active = 0;
+    const waiting = [];
+    const startNextWaiting = () => {
+        waiting.shift()?.();
+    };
+    const release = () => {
+        active -= 1;
+        startNextWaiting();
+    };
+    return {
+        run: (start, isStillWanted) => new Promise((resolve, reject) => {
+            const begin = () => {
+                if (isStillWanted && !isStillWanted()) {
+                    // The slot was never taken, so pass it on rather than release it.
+                    reject(new QueuedConnectCancelledError());
+                    startNextWaiting();
+                    return;
+                }
+                active += 1;
+                start().then(resolve, reject).finally(release);
+            };
+            if (active < limit) {
+                begin();
+            }
+            else {
+                waiting.push(begin);
+            }
+        }),
+    };
+};
 // Bumped by every initializeClientsFromSettings pass. Connections are started
 // fire-and-forget and settle long after the pass that started them returned, so
 // a callback needs to know whether a later pass has run before it writes its
@@ -1205,6 +1282,15 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
     const existingServerInfos = serverInfos;
     const nextServerInfos = [];
     const generation = ++initGeneration;
+    const concurrency = resolveStartupConcurrency();
+    const connectGate = createConnectGate(concurrency);
+    // Set once this pass swaps its entries into `serverInfos`. Until then a
+    // queued server cannot have been retired by anyone, because the entry that
+    // `closeServer`/`toggleServerStatus` would act on is not published yet.
+    let entriesPublished = false;
+    if (isInit && concurrency > 0) {
+        logger.log(`Connecting upstream servers with a concurrency limit of ${concurrency}`);
+    }
     try {
         for (const conf of allServers) {
             const { name } = conf;
@@ -1499,7 +1585,33 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                 const current = serverInfos.find((si) => si.name === name);
                 return current && current.client === client ? current : undefined;
             };
-            connectClientWithDiagnostics(client, transport, initRequestOptions || requestOptions)
+            // A queued connection has not spawned anything yet, so cancelling it is
+            // free - and necessary: `closeServerRuntime` clears the client/transport
+            // references that would later own the child process, so connecting after
+            // a disable strands a process nothing can clean up.
+            const connectStillWanted = () => {
+                // Until this pass publishes its entries, nothing else can have retired
+                // this server: the entry a disable would act on does not exist yet.
+                if (!entriesPublished)
+                    return true;
+                const current = serverInfos.find((si) => si.name === name);
+                // Gone from the configuration while it waited.
+                if (!current)
+                    return false;
+                // Client identity, not the generation, decides whether anyone is still
+                // waiting on this connect - the same rule liveServerInfo() applies to
+                // the result. A later pass that *preserved* this server spreads our
+                // client into its entry and relies on this very connect to complete it
+                // (a scoped reload preserves every other server whatever its status,
+                // see #921), so cancelling on generation alone would strand it on
+                // 'connecting' for good - the failure #1150 was about. A later pass
+                // that rebuilt the server carries a client of its own, and disabling
+                // closes the runtime before replacing the entry, so in both of those
+                // cases the published entry no longer carries our client.
+                return current.client === client && current.enabled !== false;
+            };
+            connectGate
+                .run(() => connectClientWithDiagnostics(client, transport, initRequestOptions || requestOptions), connectStillWanted)
                 .then(() => {
                 const info = liveServerInfo();
                 if (!info) {
@@ -1592,6 +1704,11 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                 }
             })
                 .catch(async (error) => {
+                if (error instanceof QueuedConnectCancelledError) {
+                    logger.log(`Cancelled queued connection for server: ${name} (disabled, removed or superseded while queued)`);
+                    closeServerRuntime(serverInfo);
+                    return;
+                }
                 const info = liveServerInfo();
                 if (!info) {
                     logger.log(`Discarding superseded connection failure for server: ${name}`);
@@ -1631,10 +1748,11 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
         throw error;
     }
     serverInfos = nextServerInfos;
+    entriesPublished = true;
     // Populate the tool cache for on-demand stdio servers so their tools are
     // visible to agents, then put them back to sleep. Running here (rather than
     // only at startup) also covers servers added/enabled/reloaded after startup.
-    const primePromise = primeOnDemandServers();
+    const primePromise = primeOnDemandServers(connectGate);
     // At full startup (no serverName) keep prime fire-and-forget so a slow or
     // broken on-demand server does not block init. For a targeted reload/edit
     // (serverName set), await it so the caller - and the dashboard refresh that
@@ -1734,9 +1852,14 @@ export const getServersInfo = async (page, limit, user) => {
         const enabled = serverConfig ? serverConfig.enabled !== false : true;
         const resolvedType = inferServerType(serverConfig);
         const oauthConnected = Boolean(serverConfig?.oauth?.accessToken || serverConfig?.oauth?.refreshToken);
-        // Add enabled status and custom description to each tool
+        // Add enabled status and custom description to each tool.
+        // toggleTool stores under whatever key the caller passed (prefixed,
+        // as the dashboard sends, or bare, as a direct API call may) with no
+        // normalization — check both so the dashboard reflects a disable set
+        // either way instead of always showing enabled:true for one of them.
         const toolsWithEnabled = tools.map((tool) => {
-            const toolConfig = serverConfig?.tools?.[tool.name];
+            const bareToolName = normalizeToolNameForServer(name, tool.name);
+            const toolConfig = serverConfig?.tools?.[tool.name] ?? serverConfig?.tools?.[bareToolName];
             return buildToolWithDescriptionMetadata(tool, toolConfig);
         });
         const promptsWithEnabled = prompts.map((prompt) => {
@@ -1871,7 +1994,9 @@ export const reinstallServer = async (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);
+        // Pass the server's own arguments so the npx clear can be scoped to this
+        // server's package instead of discarding every npx server's install.
+        await clearRunnerCache(command, serverConfig.args || []);
         // Close and reconnect (will pick up pendingReinstalls flag for uvx)
         await reconnectServer(serverName);
         logger.log(`Successfully initiated reinstall for server: ${serverName}`);
@@ -1890,7 +2015,11 @@ const filterToolsByConfig = async (serverName, tools) => {
         return tools;
     }
     return tools.filter((tool) => {
-        const toolConfig = serverConfig.tools?.[tool.name];
+        // toggleTool stores the disable under whatever key string the caller used
+        // (bare upstream name or server-prefixed name, never normalized) — check
+        // both, same as findToolOnServer's execution-time gate.
+        const bareToolName = normalizeToolNameForServer(serverName, tool.name);
+        const toolConfig = serverConfig.tools?.[tool.name] ?? serverConfig.tools?.[bareToolName];
         // If tool is not in config, it's enabled by default
         return toolConfig?.enabled !== false;
     });
@@ -2251,7 +2380,7 @@ const isStdioServer = (conf) => !!conf && (conf.type === 'stdio' || (!conf.type
  * does not block init. Each server is isolated so one failure does not affect
  * the others. See #1029 / #1032.
  */
-const primeOnDemandServers = () => {
+const primeOnDemandServers = (gate) => {
     const targets = serverInfos.filter((si) => si.config?.startOnDemand === true &&
         !hasCredentialTemplate(si.config) &&
         isStdioServer(si.config) &&
@@ -2260,9 +2389,13 @@ const primeOnDemandServers = () => {
     if (targets.length === 0)
         return Promise.resolve();
     logger.log(`Priming ${targets.length} on-demand server(s) for tool discovery…`);
+    // Priming happens right after init, so it competes for the same machine.
+    // Share the pass's concurrency limit rather than waking every sleeping server
+    // at once and undoing the pacing above.
+    const run = gate ? gate.run : (start) => start();
     return Promise.allSettled(targets.map(async (si) => {
         try {
-            await ensureServerReady(si);
+            await run(() => ensureServerReady(si));
             // 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');
@@ -2482,8 +2615,36 @@ 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 ||
+    const tool = serverInfo.tools.find((tool) => tool.name === toolName ||
         (allowRawName && normalizeToolNameForServer(serverInfo.name, tool.name) === toolName));
+    if (!tool) {
+        return undefined;
+    }
+    // A tool disabled via POST /api/servers/:server/tools/:tool/toggle must be
+    // unresolvable for execution, not just hidden from tools/list — otherwise a
+    // caller who already knows the tool name can invoke it regardless of the
+    // disabled flag.
+    //
+    // The runtime tool cache (serverInfo.tools, built by normalizeToolForCache)
+    // never carries an `enabled` field — that field only exists on the
+    // *projection* built for the dashboard/API (buildToolWithDescriptionMetadata),
+    // which is a different object. So the persisted per-tool config must be
+    // consulted directly here.
+    //
+    // toggleTool (serverController.ts) stores `tools[toolName] = ...` using
+    // whatever string the caller passed as :toolName, with no normalization.
+    // The dashboard sends the already-prefixed `tool.name`, matching what
+    // getServersInfo's toolsWithEnabled already reads — but any other caller
+    // (REST API used directly, scripts, docs examples) can just as validly
+    // pass the bare upstream name, which then never matches a prefixed-only
+    // lookup. Check both so a disable takes effect regardless of which form
+    // was used to set it.
+    const bareToolName = normalizeToolNameForServer(serverInfo.name, tool.name);
+    const toolConfig = serverInfo.config?.tools?.[tool.name] ?? serverInfo.config?.tools?.[bareToolName];
+    if (toolConfig && toolConfig.enabled === false) {
+        return undefined;
+    }
+    return tool;
 };
 const assertToolAvailableForRoute = (tool, appsRouteContext) => {
     if (isAppOnlyTool(tool) && !appsRouteContext.enabled) {
@@ -3593,13 +3754,8 @@ export const createMcpServer = (name, version, options) => {
     return server;
 };
 export const getFilteredServerInfosForGroup = async (group, options) => {
-    // Resolve group server configs. We look up the group directly from the DAO
-    // rather than going through getServerConfigsInGroup (which calls getAllGroups
-    // and applies filterData on groups). Groups don't carry a visibility field,
-    // so admin-owned groups would be filtered out for non-admin users even though
-    // bearer-key auth already authorized access and individual servers inside the
-    // group may be public. Server-level filterData below still enforces per-server
-    // visibility. Fix for #914.
+    // Resolve raw groups so legacy routing remains compatible, then enforce explicit visibility.
+    let matchedGroup = false;
     let serverConfigs = [];
     if (group) {
         const groupDao = getGroupDao();
@@ -3611,6 +3767,10 @@ export const getFilteredServerInfosForGroup = async (group, options) => {
             }
         }
         if (foundGroup) {
+            matchedGroup = true;
+            if (!canAccessGroupRoute(foundGroup)) {
+                return { filteredServerInfos: [], serverConfigsByName: new Map() };
+            }
             serverConfigs = normalizeGroupServers(foundGroup.servers || []);
         }
     }
@@ -3626,7 +3786,7 @@ export const getFilteredServerInfosForGroup = async (group, options) => {
             filteredServerInfos.push(serverInfo);
             continue;
         }
-        if (serverNamesInGroup.size === 0) {
+        if (!matchedGroup) {
             if (serverInfo.name === group) {
                 filteredServerInfos.push(serverInfo);
             }