@samanhappy/mcphub 1.1.15 → 1.2.0

package/dist/services/mcpService.js

@@ -1,4 +1,7 @@
 import { getToolPolicy } from './toolPolicyService.js';
+import { isDeepStrictEqual } from 'node:util';
+import { isReplicaMode } from '../utils/replicaMode.js';
+import { withReplicaLock } from './replicaLock.js';
 import { projectGroupToolName, assertValidGroupToolNames } from '../utils/groupToolNames.js';
 import { isSafePassthroughHeader } from '../utils/passthroughHeaders.js';
 import { observeToolCall, setMetricsServer } from './metricsService.js';
@@ -45,7 +48,7 @@ import { removeServerToolEmbeddings, removeToolEmbeddings, saveToolsAsVectorEmbe
 import { OpenAPIClient } from '../clients/openapi.js';
 import { RequestContextService } from './requestContextService.js';
 import { getDataService } from './services.js';
-import { getBearerKeyDao, getServerDao, getGroupDao, getSystemConfigDao, getBuiltinPromptDao, getBuiltinResourceDao, } from '../dao/index.js';
+import { getBearerKeyDao, getServerDao, getGroupDao, getSystemConfigDao, getBuiltinPromptDao, getBuiltinResourceDao, getCredentialBindingDao, } from '../dao/index.js';
 import { initializeAllOAuthClients } from './oauthService.js';
 import { createOAuthProvider } from './mcpOAuthProvider.js';
 import { initSmartRoutingService, getSmartRoutingTools, handleSearchToolsRequest, handleDescribeToolRequest, isSmartRoutingGroup, } from './smartRoutingService.js';
@@ -986,7 +989,7 @@ const createUpstreamMcpClient = (name, getServerInfo, serverConfig, downstream)
     });
     if (elicitation && downstream)
         installElicitationRelay(client, downstream);
-    return client;
+    return protectReplicaOAuthClient(client, name, serverConfig);
 };
 // Normalize and infer server type for safe client display
 const normalizeServerType = (type) => {
@@ -1484,6 +1487,9 @@ const refreshCapabilitiesAfterFailedCall = async (info) => {
 };
 // Helper function to handle client.callTool with reconnection logic
 const callToolWithReconnect = async (serverInfo, toolParams, options, maxRetries = 1, isolated, extra) => {
+    // A lost response does not prove a side effect failed; replica failover never replays it.
+    if (isReplicaMode())
+        maxRetries = 0;
     // Local, reassignable refs so a reconnect can swap in the new connection for
     // the next retry attempt. For isolated calls these track the per-session
     // client/transport; otherwise they mirror the shared serverInfo connection.
@@ -1678,7 +1684,7 @@ const setupServerKeepAlive = (serverInfo, serverConfig) => {
 };
 // Initialize MCP server clients
 export const initializeClientsFromSettings = async (isInit, serverName, options) => {
-    const allServers = await getServerDao().findAll();
+    const allServers = options?.declarations ?? await getServerDao().findAll();
     const existingServerInfos = serverInfos;
     const nextServerInfos = [];
     const generation = ++initGeneration;
@@ -1705,6 +1711,13 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
             }
             // Expand environment variables in all configuration values
             const expandedConf = await expandServerConfig(conf);
+            if (options?.preserveExisting) {
+                const existing = existingServerInfos.find((info) => info.name === name);
+                if (existing) {
+                    nextServerInfos.push(existing);
+                    continue;
+                }
+            }
             // Skip disabled servers
             if (expandedConf.enabled === false) {
                 logger.log(`Skipping disabled server: ${name}`);
@@ -2190,6 +2203,24 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
     }
     return serverInfos;
 };
+export const reconcileReplicaServers = async (declarations) => {
+    const expanded = new Map();
+    for (const declaration of declarations) {
+        const resolved = await expandServerConfig(declaration);
+        validateCredentialTemplate(resolved);
+        validateMaxBufferSize(resolved.options?.maxBufferSize);
+        expanded.set(declaration.name, resolved);
+    }
+    const changed = serverInfos.filter((info) => !isDeepStrictEqual(info.config, expanded.get(info.name)) ||
+        (info.enabled !== false) !== (expanded.get(info.name)?.enabled !== false));
+    for (const info of changed)
+        closeServer(info.name);
+    serverInfos = serverInfos.filter((info) => !changed.includes(info));
+    await initializeClientsFromSettings(false, undefined, { declarations, preserveExisting: true });
+    broadcastToolListChanged();
+    broadcastResourceListChanged();
+    broadcastPromptListChanged();
+};
 // Register all MCP tools
 export const registerAllTools = async (isInit, serverName, options) => {
     await initializeClientsFromSettings(isInit, serverName, options);
@@ -4343,6 +4374,7 @@ const handleReadResourceRequestImpl = async (request, extra) => {
 };
 // Preserve credential-safe errors for personal clients in every discovery scope.
 const personalClientMethods = new Set([
+    'connect',
     'callTool',
     'getPrompt',
     'readResource',
@@ -4351,7 +4383,33 @@ const personalClientMethods = new Set([
     'listResources',
     'listResourceTemplates',
 ]);
-const protectPersonalClient = (client, info, resolvedConfig) => new Proxy(client, {
+const protectReplicaOAuthClient = (client, name, definition) => {
+    if (!isReplicaMode() || !definition.url || !definition.oauth)
+        return client;
+    return new Proxy(client, {
+        get(target, property) {
+            const value = Reflect.get(target, property);
+            if (typeof value !== 'function')
+                return value;
+            if (!personalClientMethods.has(String(property)))
+                return value.bind(target);
+            return (...args) => {
+                const personal = personalOAuthContexts.get(definition);
+                const scope = JSON.stringify(['oauth', name, personal?.username || 'shared']);
+                return withReplicaLock(scope, async () => {
+                    if (personal) {
+                        await personal.assertCurrent();
+                        const binding = await getCredentialBindingDao().get(name, personal.username);
+                        if (binding?.encryptedValues !== personal.version)
+                            throw new Error('Personal authorization changed; retry with current credentials');
+                    }
+                    return value.apply(target, args);
+                });
+            };
+        },
+    });
+};
+const protectPersonalClient = (client, info, resolvedConfig) => new Proxy(protectReplicaOAuthClient(client, info.name, resolvedConfig), {
     get(target, property) {
         const value = Reflect.get(target, property);
         if (typeof value !== 'function')
@@ -4423,10 +4481,10 @@ const createPrincipalRuntime = async (name, resolvedConfig, scope, toolsOnly = f
             });
             info.transport = transport;
             info.client = protectPersonalClient(client, info, resolvedConfig);
-            await client.connect(transport, resolvedConfig.options || {});
+            await info.client.connect(transport, resolvedConfig.options || {});
             const capabilities = client.getServerCapabilities();
             if (capabilities?.tools) {
-                const { tools } = await client.listTools({}, resolvedConfig.options);
+                const { tools } = await info.client.listTools({}, resolvedConfig.options);
                 info.tools = preserveListFreshness(tools, tools.map((tool) => normalizeToolForCache(name, tool)));
                 recordCapabilitySnapshot(info, tools);
             }
@@ -4894,7 +4952,52 @@ const withToolPolicy = async (handler, request, extra, invocation) => {
     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));
+// Polling refreshes connections; authorization always reads the current shared records.
+const withReplicaServerScope = async (action) => {
+    if (!isReplicaMode())
+        return action();
+    const context = UserContextService.getInstance();
+    const current = context.getCurrentUser();
+    const externalPrincipal = current?.credentialEligible === false ||
+        RequestContextService.getInstance().getHostedAuthContext();
+    const user = current ? externalPrincipal ? current : await getUserDao().findByUsername(current.username) : null;
+    if (current && !user)
+        throw new Error('User no longer exists');
+    const definitions = getDataService().filterData(await getServerDao().findAll(), user ?? undefined);
+    const byName = new Map(definitions.map((server) => [server.name, server]));
+    const visible = (principalServerScope.getStore() ?? serverInfos).flatMap((info) => {
+        const live = byName.get(info.name);
+        if (!live || live.enabled === false)
+            return [];
+        if (hasPersonalAuthentication(live) !== hasPersonalAuthentication(info.config))
+            return [];
+        // Project request authorization while keeping all lifecycle reads/writes on the runtime.
+        return [
+            new Proxy(info, {
+                get(target, property) {
+                    switch (property) {
+                        case 'owner':
+                        case 'visibility':
+                        case 'sharedWithUsers':
+                        case 'sharedWithUserGroups':
+                            return live[property];
+                        case 'config':
+                            return {
+                                ...target.config,
+                                tools: live.tools,
+                                prompts: live.prompts,
+                                resources: live.resources,
+                            };
+                        default:
+                            return Reflect.get(target, property);
+                    }
+                },
+            }),
+        ];
+    });
+    return context.runWithContext(() => principalServerScope.run(visible, action), user ?? null);
+};
+export const handleCallToolRequest = (request, extra) => observeToolCall(() => withReplicaServerScope(() => 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'), [