thaddeus 1.0.26 → 1.0.28

package/src/services/mcp/useManageMCPConnections.js

@@ -0,0 +1,818 @@
+import { feature } from 'bun:bundle';
+import { basename } from 'path';
+import { useCallback, useEffect, useRef } from 'react';
+import { getSessionId } from '../../bootstrap/state.js';
+import { clearServerCache, fetchCommandsForClient, fetchResourcesForClient, fetchToolsForClient, getMcpToolsCommandsAndResources, reconnectMcpServerImpl, } from './client.js';
+/* eslint-disable @typescript-eslint/no-require-imports */
+const fetchMcpSkillsForClient = feature('MCP_SKILLS')
+    ? require('../../skills/mcpSkills.js').fetchMcpSkillsForClient
+    : null;
+const clearSkillIndexCache = feature('EXPERIMENTAL_SKILL_SEARCH')
+    ? require('../skillSearch/localSearch.js').clearSkillIndexCache
+    : null;
+import { PromptListChangedNotificationSchema, ResourceListChangedNotificationSchema, ToolListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
+import omit from 'lodash-es/omit.js';
+import reject from 'lodash-es/reject.js';
+import { logEvent, } from 'src/services/analytics/index.js';
+import { dedupClaudeAiMcpServers, doesEnterpriseMcpConfigExist, filterMcpServersByPolicy, getThaddeusMcpConfigs, isMcpServerDisabled, setMcpServerEnabled, } from 'src/services/mcp/config.js';
+import { logForDebugging } from 'src/utils/debug.js';
+import { getAllowedChannels } from '../../bootstrap/state.js';
+import { useNotifications } from '../../context/notifications.js';
+import { useAppState, useAppStateStore, useSetAppState, } from '../../state/AppState.js';
+import { errorMessage } from '../../utils/errors.js';
+/* eslint-enable @typescript-eslint/no-require-imports */
+import { logMCPDebug, logMCPError } from '../../utils/log.js';
+import { enqueue } from '../../utils/messageQueueManager.js';
+import { CHANNEL_PERMISSION_METHOD, ChannelMessageNotificationSchema, ChannelPermissionNotificationSchema, findChannelEntry, gateChannelServer, wrapChannelMessage, } from './channelNotification.js';
+import { createChannelPermissionCallbacks, isChannelPermissionRelayEnabled, } from './channelPermissions.js';
+import { clearClaudeAIMcpConfigsCache, fetchClaudeAIMcpConfigsIfEligible, } from './claudeai.js';
+import { registerElicitationHandler } from './elicitationHandler.js';
+import { getMcpPrefix } from './mcpStringUtils.js';
+import { commandBelongsToServer, excludeStalePluginClients } from './utils.js';
+// Constants for reconnection with exponential backoff
+const MAX_RECONNECT_ATTEMPTS = 5;
+const INITIAL_BACKOFF_MS = 1000;
+const MAX_BACKOFF_MS = 30000;
+/**
+ * Create a unique key for a plugin error to enable deduplication
+ */
+function getErrorKey(error) {
+    const plugin = 'plugin' in error ? error.plugin : 'no-plugin';
+    return `${error.type}:${error.source}:${plugin}`;
+}
+/**
+ * Add errors to AppState, deduplicating to avoid showing the same error multiple times
+ */
+function addErrorsToAppState(setAppState, newErrors) {
+    if (newErrors.length === 0)
+        return;
+    setAppState(prevState => {
+        // Build set of existing error keys
+        const existingKeys = new Set(prevState.plugins.errors.map(e => getErrorKey(e)));
+        // Only add errors that don't already exist
+        const uniqueNewErrors = newErrors.filter(error => !existingKeys.has(getErrorKey(error)));
+        if (uniqueNewErrors.length === 0) {
+            return prevState;
+        }
+        return {
+            ...prevState,
+            plugins: {
+                ...prevState.plugins,
+                errors: [...prevState.plugins.errors, ...uniqueNewErrors],
+            },
+        };
+    });
+}
+/**
+ * Hook to manage MCP (Model Context Protocol) server connections and updates
+ *
+ * This hook:
+ * 1. Initializes MCP client connections based on config
+ * 2. Sets up handlers for connection lifecycle events and sync with app state
+ * 3. Manages automatic reconnection for SSE connections
+ * 4. Returns a reconnect function
+ */
+export function useManageMCPConnections(dynamicMcpConfig, isStrictMcpConfig = false) {
+    const store = useAppStateStore();
+    const _authVersion = useAppState(s => s.authVersion);
+    // Incremented by /reload-plugins (refreshActivePlugins) to pick up newly
+    // enabled plugin MCP servers. getThaddeusMcpConfigs() reads loadAllPlugins()
+    // which has been cleared by refreshActivePlugins, so the effects below see
+    // fresh plugin data on re-run.
+    const _pluginReconnectKey = useAppState(s => s.mcp.pluginReconnectKey);
+    const setAppState = useSetAppState();
+    // Track active reconnection attempts to allow cancellation
+    const reconnectTimersRef = useRef(new Map());
+    // Dedup the --channels blocked warning per skip kind so that a user who
+    // sees "run /login" (auth skip), logs in, then hits the policy gate
+    // gets a second toast.
+    const channelWarnedKindsRef = useRef(new Set());
+    // Channel permission callbacks — constructed once, stable ref. Stored in
+    // AppState so interactiveHandler can subscribe. The pending Map lives inside
+    // the closure (not module-level, not AppState — functions-in-state is brittle).
+    const channelPermCallbacksRef = useRef(null);
+    if ((feature('KAIROS') || feature('KAIROS_CHANNELS')) &&
+        channelPermCallbacksRef.current === null) {
+        channelPermCallbacksRef.current = createChannelPermissionCallbacks();
+    }
+    // Store callbacks in AppState so interactiveHandler.ts can reach them via
+    // ctx.toolUseContext.getAppState(). One-time set — the ref is stable.
+    useEffect(() => {
+        if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {
+            const callbacks = channelPermCallbacksRef.current;
+            if (!callbacks)
+                return;
+            // GrowthBook runtime gate — separate from channels so channels can
+            // ship without this. Checked at mount; mid-session flips need restart.
+            // If off, callbacks never go into AppState → interactiveHandler sees
+            // undefined → never sends → intercept has nothing pending → "yes tbxkq"
+            // flows to Claude as normal chat. One gate, full disable.
+            if (!isChannelPermissionRelayEnabled())
+                return;
+            setAppState(prev => {
+                if (prev.channelPermissionCallbacks === callbacks)
+                    return prev;
+                return { ...prev, channelPermissionCallbacks: callbacks };
+            });
+            return () => {
+                setAppState(prev => {
+                    if (prev.channelPermissionCallbacks === undefined)
+                        return prev;
+                    return { ...prev, channelPermissionCallbacks: undefined };
+                });
+            };
+        }
+    }, [setAppState]);
+    const { addNotification } = useNotifications();
+    // Batched MCP state updates: queue individual server updates and flush them
+    // in a single setAppState call via setTimeout. Using a time-based window
+    // (instead of queueMicrotask) ensures updates are batched even when
+    // connection callbacks arrive at different times due to network I/O.
+    const MCP_BATCH_FLUSH_MS = 16;
+    const pendingUpdatesRef = useRef([]);
+    const flushTimerRef = useRef(null);
+    const flushPendingUpdates = useCallback(() => {
+        flushTimerRef.current = null;
+        const updates = pendingUpdatesRef.current;
+        if (updates.length === 0)
+            return;
+        pendingUpdatesRef.current = [];
+        setAppState(prevState => {
+            let mcp = prevState.mcp;
+            for (const update of updates) {
+                const { tools: rawTools, commands: rawCmds, resources: rawRes, ...client } = update;
+                const tools = client.type === 'disabled' || client.type === 'failed'
+                    ? (rawTools ?? [])
+                    : rawTools;
+                const commands = client.type === 'disabled' || client.type === 'failed'
+                    ? (rawCmds ?? [])
+                    : rawCmds;
+                const resources = client.type === 'disabled' || client.type === 'failed'
+                    ? (rawRes ?? [])
+                    : rawRes;
+                const prefix = getMcpPrefix(client.name);
+                const existingClientIndex = mcp.clients.findIndex(c => c.name === client.name);
+                const updatedClients = existingClientIndex === -1
+                    ? [...mcp.clients, client]
+                    : mcp.clients.map(c => (c.name === client.name ? client : c));
+                const updatedTools = tools === undefined
+                    ? mcp.tools
+                    : [...reject(mcp.tools, t => t.name?.startsWith(prefix)), ...tools];
+                const updatedCommands = commands === undefined
+                    ? mcp.commands
+                    : [
+                        ...reject(mcp.commands, c => commandBelongsToServer(c, client.name)),
+                        ...commands,
+                    ];
+                const updatedResources = resources === undefined
+                    ? mcp.resources
+                    : {
+                        ...mcp.resources,
+                        ...(resources.length > 0
+                            ? { [client.name]: resources }
+                            : omit(mcp.resources, client.name)),
+                    };
+                mcp = {
+                    ...mcp,
+                    clients: updatedClients,
+                    tools: updatedTools,
+                    commands: updatedCommands,
+                    resources: updatedResources,
+                };
+            }
+            return { ...prevState, mcp };
+        });
+    }, [setAppState]);
+    // Update server state, tools, commands, and resources.
+    // When tools, commands, or resources are undefined, the existing values are preserved.
+    // When type is 'disabled' or 'failed', tools/commands/resources are automatically cleared.
+    // Updates are batched via setTimeout to coalesce updates arriving within MCP_BATCH_FLUSH_MS.
+    const updateServer = useCallback((update) => {
+        pendingUpdatesRef.current.push(update);
+        if (flushTimerRef.current === null) {
+            flushTimerRef.current = setTimeout(flushPendingUpdates, MCP_BATCH_FLUSH_MS);
+        }
+    }, [flushPendingUpdates]);
+    const onConnectionAttempt = useCallback(({ client, tools, commands, resources, }) => {
+        updateServer({ ...client, tools, commands, resources });
+        // Handle side effects based on client state
+        switch (client.type) {
+            case 'connected': {
+                // Overwrite the default elicitation handler registered in connectToServer
+                // with the real one (queues elicitation in AppState for UI). Registering
+                // here (once per connect) instead of in a [mcpClients] effect avoids
+                // re-running for every already-connected server on each state change.
+                registerElicitationHandler(client.client, client.name, setAppState);
+                client.client.onclose = () => {
+                    const configType = client.config.type ?? 'stdio';
+                    clearServerCache(client.name, client.config).catch(() => {
+                        logForDebugging(`Failed to invalidate the server cache: ${client.name}`);
+                    });
+                    // TODO: This really isn't great: ideally we'd check appstate as the source of truth
+                    // as to whether it was disconnected due to a disable, but appstate is stale at this
+                    // point. Getting a live reference to appstate feels a little hacky, so we'll just
+                    // check the disk state. We may want to refactor some of this.
+                    if (isMcpServerDisabled(client.name)) {
+                        logMCPDebug(client.name, `Server is disabled, skipping automatic reconnection`);
+                        return;
+                    }
+                    // Handle automatic reconnection for remote transports
+                    // Skip stdio (local process) and sdk (internal) - they don't support reconnection
+                    if (configType !== 'stdio' && configType !== 'sdk') {
+                        const transportType = getTransportDisplayName(configType);
+                        logMCPDebug(client.name, `${transportType} transport closed/disconnected, attempting automatic reconnection`);
+                        // Cancel any existing reconnection attempt for this server
+                        const existingTimer = reconnectTimersRef.current.get(client.name);
+                        if (existingTimer) {
+                            clearTimeout(existingTimer);
+                            reconnectTimersRef.current.delete(client.name);
+                        }
+                        // Attempt reconnection with exponential backoff
+                        const reconnectWithBackoff = async () => {
+                            for (let attempt = 1; attempt <= MAX_RECONNECT_ATTEMPTS; attempt++) {
+                                // Check if server was disabled while we were waiting
+                                if (isMcpServerDisabled(client.name)) {
+                                    logMCPDebug(client.name, `Server disabled during reconnection, stopping retry`);
+                                    reconnectTimersRef.current.delete(client.name);
+                                    return;
+                                }
+                                updateServer({
+                                    ...client,
+                                    type: 'pending',
+                                    reconnectAttempt: attempt,
+                                    maxReconnectAttempts: MAX_RECONNECT_ATTEMPTS,
+                                });
+                                const reconnectStartTime = Date.now();
+                                try {
+                                    const result = await reconnectMcpServerImpl(client.name, client.config);
+                                    const elapsed = Date.now() - reconnectStartTime;
+                                    if (result.client.type === 'connected') {
+                                        logMCPDebug(client.name, `${transportType} reconnection successful after ${elapsed}ms (attempt ${attempt})`);
+                                        reconnectTimersRef.current.delete(client.name);
+                                        onConnectionAttempt(result);
+                                        return;
+                                    }
+                                    logMCPDebug(client.name, `${transportType} reconnection attempt ${attempt} completed with status: ${result.client.type}`);
+                                    // On final attempt, update state with the result
+                                    if (attempt === MAX_RECONNECT_ATTEMPTS) {
+                                        logMCPDebug(client.name, `Max reconnection attempts (${MAX_RECONNECT_ATTEMPTS}) reached, giving up`);
+                                        reconnectTimersRef.current.delete(client.name);
+                                        onConnectionAttempt(result);
+                                        return;
+                                    }
+                                }
+                                catch (error) {
+                                    const elapsed = Date.now() - reconnectStartTime;
+                                    logMCPError(client.name, `${transportType} reconnection attempt ${attempt} failed after ${elapsed}ms: ${error}`);
+                                    // On final attempt, mark as failed
+                                    if (attempt === MAX_RECONNECT_ATTEMPTS) {
+                                        logMCPDebug(client.name, `Max reconnection attempts (${MAX_RECONNECT_ATTEMPTS}) reached, giving up`);
+                                        reconnectTimersRef.current.delete(client.name);
+                                        updateServer({ ...client, type: 'failed' });
+                                        return;
+                                    }
+                                }
+                                // Schedule next retry with exponential backoff
+                                const backoffMs = Math.min(INITIAL_BACKOFF_MS * Math.pow(2, attempt - 1), MAX_BACKOFF_MS);
+                                logMCPDebug(client.name, `Scheduling reconnection attempt ${attempt + 1} in ${backoffMs}ms`);
+                                await new Promise(resolve => {
+                                    // eslint-disable-next-line no-restricted-syntax -- timer stored in ref for cancellation; sleep() doesn't expose the handle
+                                    const timer = setTimeout(resolve, backoffMs);
+                                    reconnectTimersRef.current.set(client.name, timer);
+                                });
+                            }
+                        };
+                        void reconnectWithBackoff();
+                    }
+                    else {
+                        updateServer({ ...client, type: 'failed' });
+                    }
+                };
+                // Channel push: notifications/claude/channel → enqueue().
+                // Gate decides whether to register the handler; connection stays
+                // up either way (allowedMcpServers controls that).
+                if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {
+                    const gate = gateChannelServer(client.name, client.capabilities, client.config.pluginSource);
+                    const entry = findChannelEntry(client.name, getAllowedChannels());
+                    // Plugin identifier for telemetry — log name@marketplace for any
+                    // plugin-kind entry (same tier as thaddeus_plugin_installed, which
+                    // logs arbitrary plugin_id+marketplace_name ungated). server-kind
+                    // names are MCP-server-name tier; those are opt-in-only elsewhere
+                    // (see isAnalyticsToolDetailsLoggingEnabled in metadata.ts) and
+                    // stay unlogged here. is_dev/entry_kind segment the rest.
+                    const pluginId = entry?.kind === 'plugin'
+                        ? `${entry.name}@${entry.marketplace}`
+                        : undefined;
+                    // Skip capability-miss — every non-channel MCP server trips it.
+                    if (gate.action === 'register' || gate.kind !== 'capability') {
+                        logEvent('thaddeus_mcp_channel_gate', {
+                            registered: gate.action === 'register',
+                            skip_kind: gate.action === 'skip'
+                                ? gate.kind
+                                : undefined,
+                            entry_kind: entry?.kind,
+                            is_dev: entry?.dev ?? false,
+                            plugin: pluginId,
+                        });
+                    }
+                    switch (gate.action) {
+                        case 'register':
+                            logMCPDebug(client.name, 'Channel notifications registered');
+                            client.client.setNotificationHandler(ChannelMessageNotificationSchema(), async (notification) => {
+                                const { content, meta } = notification.params;
+                                logMCPDebug(client.name, `notifications/claude/channel: ${content.slice(0, 80)}`);
+                                logEvent('thaddeus_mcp_channel_message', {
+                                    content_length: content.length,
+                                    meta_key_count: Object.keys(meta ?? {}).length,
+                                    entry_kind: entry?.kind,
+                                    is_dev: entry?.dev ?? false,
+                                    plugin: pluginId,
+                                });
+                                enqueue({
+                                    mode: 'prompt',
+                                    value: wrapChannelMessage(client.name, content, meta),
+                                    priority: 'next',
+                                    isMeta: true,
+                                    origin: { kind: 'channel', server: client.name },
+                                    skipSlashCommands: true,
+                                });
+                            });
+                            // Permission-reply handler — separate event, separate
+                            // capability. Only registers if the server declares
+                            // claude/channel/permission (same opt-in check as the send
+                            // path in interactiveHandler.ts). Server parses the user's
+                            // reply and emits {request_id, behavior}; no regex on our
+                            // side, text in the general channel can't accidentally match.
+                            if (client.capabilities?.experimental?.['claude/channel/permission'] !== undefined) {
+                                client.client.setNotificationHandler(ChannelPermissionNotificationSchema(), async (notification) => {
+                                    const { request_id, behavior } = notification.params;
+                                    const resolved = channelPermCallbacksRef.current?.resolve(request_id, behavior, client.name) ?? false;
+                                    logMCPDebug(client.name, `notifications/claude/channel/permission: ${request_id} → ${behavior} (${resolved ? 'matched pending' : 'no pending entry — stale or unknown ID'})`);
+                                });
+                            }
+                            break;
+                        case 'skip':
+                            // Idempotent teardown so a register→skip re-gate (e.g.
+                            // effect re-runs after /logout) actually removes the live
+                            // handler. Without this, mid-session demotion is one-way:
+                            // the gate says skip but the earlier handler keeps enqueuing.
+                            // Map.delete — safe when never registered.
+                            client.client.removeNotificationHandler('notifications/claude/channel');
+                            client.client.removeNotificationHandler(CHANNEL_PERMISSION_METHOD);
+                            logMCPDebug(client.name, `Channel notifications skipped: ${gate.reason}`);
+                            // Surface a once-per-kind toast when a channel server is
+                            // blocked. This is the only
+                            // user-visible signal (logMCPDebug above requires --debug).
+                            // Capability/session skips are expected noise and stay
+                            // debug-only. marketplace/allowlist run after session — if
+                            // we're here with those kinds, the user asked for it.
+                            if (gate.kind !== 'capability' &&
+                                gate.kind !== 'session' &&
+                                !channelWarnedKindsRef.current.has(gate.kind) &&
+                                (gate.kind === 'marketplace' ||
+                                    gate.kind === 'allowlist' ||
+                                    entry !== undefined)) {
+                                channelWarnedKindsRef.current.add(gate.kind);
+                                // disabled/auth/policy get custom toast copy (shorter, actionable);
+                                // marketplace/allowlist reuse the gate's reason verbatim
+                                // since it already names the mismatch.
+                                const text = gate.kind === 'disabled'
+                                    ? 'Channels are not currently available'
+                                    : gate.kind === 'auth'
+                                        ? 'Channels require authentication · run /login'
+                                        : gate.kind === 'policy'
+                                            ? 'Channels are not enabled for your org · have an administrator set channelsEnabled: true in managed settings'
+                                            : gate.reason;
+                                addNotification({
+                                    key: `channels-blocked-${gate.kind}`,
+                                    priority: 'high',
+                                    text,
+                                    color: 'warning',
+                                    timeoutMs: 12000,
+                                });
+                            }
+                            break;
+                    }
+                }
+                // Register notification handlers for list_changed notifications
+                // These allow the server to notify us when tools, prompts, or resources change
+                if (client.capabilities?.tools?.listChanged) {
+                    client.client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
+                        logMCPDebug(client.name, `Received tools/list_changed notification, refreshing tools`);
+                        try {
+                            // Grab cached promise before invalidating to log previous count
+                            const previousToolsPromise = fetchToolsForClient.cache.get(client.name);
+                            fetchToolsForClient.cache.delete(client.name);
+                            const newTools = await fetchToolsForClient(client);
+                            const newCount = newTools.length;
+                            if (previousToolsPromise) {
+                                previousToolsPromise.then((previousTools) => {
+                                    logEvent('thaddeus_mcp_list_changed', {
+                                        type: 'tools',
+                                        previousCount: previousTools.length,
+                                        newCount,
+                                    });
+                                }, () => {
+                                    logEvent('thaddeus_mcp_list_changed', {
+                                        type: 'tools',
+                                        newCount,
+                                    });
+                                });
+                            }
+                            else {
+                                logEvent('thaddeus_mcp_list_changed', {
+                                    type: 'tools',
+                                    newCount,
+                                });
+                            }
+                            updateServer({ ...client, tools: newTools });
+                        }
+                        catch (error) {
+                            logMCPError(client.name, `Failed to refresh tools after list_changed notification: ${errorMessage(error)}`);
+                        }
+                    });
+                }
+                if (client.capabilities?.prompts?.listChanged) {
+                    client.client.setNotificationHandler(PromptListChangedNotificationSchema, async () => {
+                        logMCPDebug(client.name, `Received prompts/list_changed notification, refreshing prompts`);
+                        logEvent('thaddeus_mcp_list_changed', {
+                            type: 'prompts',
+                        });
+                        try {
+                            // Skills come from resources, not prompts — don't invalidate their
+                            // cache here. fetchMcpSkillsForClient returns the cached result.
+                            fetchCommandsForClient.cache.delete(client.name);
+                            const [mcpPrompts, mcpSkills] = await Promise.all([
+                                fetchCommandsForClient(client),
+                                feature('MCP_SKILLS')
+                                    ? fetchMcpSkillsForClient(client)
+                                    : Promise.resolve([]),
+                            ]);
+                            updateServer({
+                                ...client,
+                                commands: [...mcpPrompts, ...mcpSkills],
+                            });
+                            // MCP skills changed — invalidate skill-search index so
+                            // next discovery rebuilds with the new set.
+                            clearSkillIndexCache?.();
+                        }
+                        catch (error) {
+                            logMCPError(client.name, `Failed to refresh prompts after list_changed notification: ${errorMessage(error)}`);
+                        }
+                    });
+                }
+                if (client.capabilities?.resources?.listChanged) {
+                    client.client.setNotificationHandler(ResourceListChangedNotificationSchema, async () => {
+                        logMCPDebug(client.name, `Received resources/list_changed notification, refreshing resources`);
+                        logEvent('thaddeus_mcp_list_changed', {
+                            type: 'resources',
+                        });
+                        try {
+                            fetchResourcesForClient.cache.delete(client.name);
+                            if (feature('MCP_SKILLS')) {
+                                // Skills are discovered from resources, so refresh them too.
+                                // Invalidate prompts cache as well: we write commands here,
+                                // and a concurrent prompts/list_changed could otherwise have
+                                // us stomp its fresh result with our cached stale one.
+                                fetchMcpSkillsForClient.cache.delete(client.name);
+                                fetchCommandsForClient.cache.delete(client.name);
+                                const [newResources, mcpPrompts, mcpSkills] = await Promise.all([
+                                    fetchResourcesForClient(client),
+                                    fetchCommandsForClient(client),
+                                    fetchMcpSkillsForClient(client),
+                                ]);
+                                updateServer({
+                                    ...client,
+                                    resources: newResources,
+                                    commands: [...mcpPrompts, ...mcpSkills],
+                                });
+                                // MCP skills changed — invalidate skill-search index so
+                                // next discovery rebuilds with the new set.
+                                clearSkillIndexCache?.();
+                            }
+                            else {
+                                const newResources = await fetchResourcesForClient(client);
+                                updateServer({ ...client, resources: newResources });
+                            }
+                        }
+                        catch (error) {
+                            logMCPError(client.name, `Failed to refresh resources after list_changed notification: ${errorMessage(error)}`);
+                        }
+                    });
+                }
+                break;
+            }
+            case 'needs-auth':
+            case 'failed':
+            case 'pending':
+            case 'disabled':
+                break;
+        }
+    }, [updateServer]);
+    // Initialize all servers to pending state if they don't exist in appState.
+    // Re-runs on session change (/clear) and on /reload-plugins (pluginReconnectKey).
+    // On plugin reload, also disconnects stale plugin MCP servers (scope 'dynamic')
+    // that no longer appear in configs — prevents ghost tools from disabled plugins.
+    // Skip claude.ai dedup here to avoid blocking on the network fetch; the connect
+    // useEffect below runs immediately after and dedups before connecting.
+    const sessionId = getSessionId();
+    useEffect(() => {
+        async function initializeServersAsPending() {
+            const { servers: existingConfigs, errors: mcpErrors } = isStrictMcpConfig
+                ? { servers: {}, errors: [] }
+                : await getThaddeusMcpConfigs(dynamicMcpConfig);
+            const configs = { ...existingConfigs, ...dynamicMcpConfig };
+            // Add MCP errors to plugin errors for UI visibility (deduplicated)
+            addErrorsToAppState(setAppState, mcpErrors);
+            setAppState(prevState => {
+                // Disconnect MCP servers that are stale: plugin servers removed from
+                // config, or any server whose config hash changed (edited .mcp.json).
+                // Stale servers get re-added as 'pending' below since their name is
+                // now absent from mcpWithoutStale.clients.
+                const { stale, ...mcpWithoutStale } = excludeStalePluginClients(prevState.mcp, configs);
+                // Clean up stale connections. Fire-and-forget — state updaters must
+                // be synchronous. Three hazards to defuse before calling cleanup:
+                //   1. Pending reconnect timer would fire with the OLD config.
+                //   2. onclose (set at L254) starts reconnectWithBackoff with the
+                //      OLD config from its closure — it checks isMcpServerDisabled
+                //      but config-changed servers aren't disabled, so it'd race the
+                //      fresh connection and last updateServer wins.
+                //   3. clearServerCache internally calls connectToServer (memoized).
+                //      For never-connected servers (disabled/pending/failed) the
+                //      cache is empty → real connect attempt → spawn/OAuth just to
+                //      immediately kill it. Only connected servers need cleanup.
+                for (const s of stale) {
+                    const timer = reconnectTimersRef.current.get(s.name);
+                    if (timer) {
+                        clearTimeout(timer);
+                        reconnectTimersRef.current.delete(s.name);
+                    }
+                    if (s.type === 'connected') {
+                        s.client.onclose = undefined;
+                        void clearServerCache(s.name, s.config).catch(() => { });
+                    }
+                }
+                const existingServerNames = new Set(mcpWithoutStale.clients.map(c => c.name));
+                const newClients = Object.entries(configs)
+                    .filter(([name]) => !existingServerNames.has(name))
+                    .map(([name, config]) => ({
+                    name,
+                    type: isMcpServerDisabled(name)
+                        ? 'disabled'
+                        : 'pending',
+                    config,
+                }));
+                if (newClients.length === 0 && stale.length === 0) {
+                    return prevState;
+                }
+                return {
+                    ...prevState,
+                    mcp: {
+                        ...prevState.mcp,
+                        ...mcpWithoutStale,
+                        clients: [...mcpWithoutStale.clients, ...newClients],
+                    },
+                };
+            });
+        }
+        void initializeServersAsPending().catch(error => {
+            logMCPError('useManageMCPConnections', `Failed to initialize servers as pending: ${errorMessage(error)}`);
+        });
+    }, [
+        isStrictMcpConfig,
+        dynamicMcpConfig,
+        setAppState,
+        sessionId,
+        _pluginReconnectKey,
+    ]);
+    // Load MCP configs and connect to servers
+    // Two-phase loading: Thaddeus configs first (fast), then Delphi Labs configs (may be slow)
+    useEffect(() => {
+        let cancelled = false;
+        async function loadAndConnectMcpConfigs() {
+            // Clear claude.ai MCP cache so we fetch fresh configs with current auth
+            // state. This is important when authVersion changes (e.g., after login/
+            // logout). Kick off the fetch now so it overlaps with loadAllPlugins()
+            // inside getThaddeusMcpConfigs; it's awaited only at the dedup step.
+            // Phase 2 below awaits the same promise — no second network call.
+            let claudeaiPromise;
+            if (isStrictMcpConfig || doesEnterpriseMcpConfigExist()) {
+                claudeaiPromise = Promise.resolve({});
+            }
+            else {
+                clearClaudeAIMcpConfigsCache();
+                claudeaiPromise = fetchClaudeAIMcpConfigsIfEligible();
+            }
+            // Phase 1: Load Thaddeus configs. Plugin MCP servers that duplicate a
+            // --mcp-config entry or a claude.ai connector are suppressed here so they
+            // don't connect alongside the connector in Phase 2.
+            const { servers: thaddeusConfigs, errors: mcpErrors } = isStrictMcpConfig
+                ? { servers: {}, errors: [] }
+                : await getThaddeusMcpConfigs(dynamicMcpConfig, claudeaiPromise);
+            if (cancelled)
+                return;
+            // Add MCP errors to plugin errors for UI visibility (deduplicated)
+            addErrorsToAppState(setAppState, mcpErrors);
+            const configs = { ...thaddeusConfigs, ...dynamicMcpConfig };
+            // Start connecting to Thaddeus servers (don't wait - runs concurrently with Phase 2)
+            // Filter out disabled servers to avoid unnecessary connection attempts
+            const enabledConfigs = Object.fromEntries(Object.entries(configs).filter(([name]) => !isMcpServerDisabled(name)));
+            getMcpToolsCommandsAndResources(onConnectionAttempt, enabledConfigs).catch(error => {
+                logMCPError('useManageMcpConnections', `Failed to get MCP resources: ${errorMessage(error)}`);
+            });
+            // Phase 2: Await claude.ai configs (started above; memoized — no second fetch)
+            let claudeaiConfigs = {};
+            if (!isStrictMcpConfig) {
+                claudeaiConfigs = filterMcpServersByPolicy(await claudeaiPromise).allowed;
+                if (cancelled)
+                    return;
+                // Suppress claude.ai connectors that duplicate an enabled manual server.
+                // Keys never collide (`slack` vs `claude.ai Slack`) so the merge below
+                // won't catch this — need content-based dedup by URL signature.
+                if (Object.keys(claudeaiConfigs).length > 0) {
+                    const { servers: dedupedClaudeAi } = dedupClaudeAiMcpServers(claudeaiConfigs, configs);
+                    claudeaiConfigs = dedupedClaudeAi;
+                }
+                if (Object.keys(claudeaiConfigs).length > 0) {
+                    // Add claude.ai servers as pending immediately so they show up in UI
+                    setAppState(prevState => {
+                        const existingServerNames = new Set(prevState.mcp.clients.map(c => c.name));
+                        const newClients = Object.entries(claudeaiConfigs)
+                            .filter(([name]) => !existingServerNames.has(name))
+                            .map(([name, config]) => ({
+                            name,
+                            type: isMcpServerDisabled(name)
+                                ? 'disabled'
+                                : 'pending',
+                            config,
+                        }));
+                        if (newClients.length === 0)
+                            return prevState;
+                        return {
+                            ...prevState,
+                            mcp: {
+                                ...prevState.mcp,
+                                clients: [...prevState.mcp.clients, ...newClients],
+                            },
+                        };
+                    });
+                    // Now start connecting (only enabled servers)
+                    const enabledClaudeaiConfigs = Object.fromEntries(Object.entries(claudeaiConfigs).filter(([name]) => !isMcpServerDisabled(name)));
+                    getMcpToolsCommandsAndResources(onConnectionAttempt, enabledClaudeaiConfigs).catch(error => {
+                        logMCPError('useManageMcpConnections', `Failed to get claude.ai MCP resources: ${errorMessage(error)}`);
+                    });
+                }
+            }
+            // Log server counts after both phases complete
+            const allConfigs = { ...configs, ...claudeaiConfigs };
+            const counts = {
+                enterprise: 0,
+                global: 0,
+                project: 0,
+                user: 0,
+                plugin: 0,
+                claudeai: 0,
+            };
+            // Ant-only: collect stdio command basenames to correlate with RSS/FPS
+            // metrics. Stdio servers like rust-analyzer can be heavy and we want to
+            // know which ones correlate with poor session performance.
+            const stdioCommands = [];
+            for (const [name, serverConfig] of Object.entries(allConfigs)) {
+                if (serverConfig.scope === 'enterprise')
+                    counts.enterprise++;
+                else if (serverConfig.scope === 'user')
+                    counts.global++;
+                else if (serverConfig.scope === 'project')
+                    counts.project++;
+                else if (serverConfig.scope === 'local')
+                    counts.user++;
+                else if (serverConfig.scope === 'dynamic')
+                    counts.plugin++;
+                else if (serverConfig.scope === 'claudeai')
+                    counts.claudeai++;
+                if (process.env.USER_TYPE === 'ant' &&
+                    !isMcpServerDisabled(name) &&
+                    (serverConfig.type === undefined || serverConfig.type === 'stdio') &&
+                    'command' in serverConfig) {
+                    stdioCommands.push(basename(serverConfig.command));
+                }
+            }
+            logEvent('thaddeus_mcp_servers', {
+                ...counts,
+                ...(process.env.USER_TYPE === 'ant' && stdioCommands.length > 0
+                    ? {
+                        stdio_commands: stdioCommands
+                            .sort()
+                            .join(','),
+                    }
+                    : {}),
+            });
+        }
+        void loadAndConnectMcpConfigs();
+        return () => {
+            cancelled = true;
+        };
+    }, [
+        isStrictMcpConfig,
+        dynamicMcpConfig,
+        onConnectionAttempt,
+        setAppState,
+        _authVersion,
+        sessionId,
+        _pluginReconnectKey,
+    ]);
+    // Cleanup all timers on unmount
+    useEffect(() => {
+        const timers = reconnectTimersRef.current;
+        return () => {
+            for (const timer of timers.values()) {
+                clearTimeout(timer);
+            }
+            timers.clear();
+            // Flush any pending batched MCP updates before unmount
+            if (flushTimerRef.current !== null) {
+                clearTimeout(flushTimerRef.current);
+                flushTimerRef.current = null;
+                flushPendingUpdates();
+            }
+        };
+    }, [flushPendingUpdates]);
+    // Expose reconnectMcpServer function for components to use.
+    // Reads mcp.clients via store.getState() so this callback stays stable
+    // across client state transitions (no need to re-create on every connect).
+    const reconnectMcpServer = useCallback(async (serverName) => {
+        const client = store
+            .getState()
+            .mcp.clients.find(c => c.name === serverName);
+        if (!client) {
+            throw new Error(`MCP server ${serverName} not found`);
+        }
+        // Cancel any pending automatic reconnection attempt
+        const existingTimer = reconnectTimersRef.current.get(serverName);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+            reconnectTimersRef.current.delete(serverName);
+        }
+        const result = await reconnectMcpServerImpl(serverName, client.config);
+        onConnectionAttempt(result);
+        // Don't throw, just let UI handle the client type in case the reconnect failed
+        // (Detailed logs are within the reconnectMcpServerImpl via --debug)
+        return result;
+    }, [store, onConnectionAttempt]);
+    // Expose function to toggle server enabled/disabled state
+    const toggleMcpServer = useCallback(async (serverName) => {
+        const client = store
+            .getState()
+            .mcp.clients.find(c => c.name === serverName);
+        if (!client) {
+            throw new Error(`MCP server ${serverName} not found`);
+        }
+        const isCurrentlyDisabled = client.type === 'disabled';
+        if (!isCurrentlyDisabled) {
+            // Cancel any pending automatic reconnection attempt
+            const existingTimer = reconnectTimersRef.current.get(serverName);
+            if (existingTimer) {
+                clearTimeout(existingTimer);
+                reconnectTimersRef.current.delete(serverName);
+            }
+            // Persist disabled state to disk FIRST before clearing cache
+            // This is important because the onclose handler checks disk state
+            setMcpServerEnabled(serverName, false);
+            // Disabling: disconnect and clean up if currently connected
+            if (client.type === 'connected') {
+                await clearServerCache(serverName, client.config);
+            }
+            // Update to disabled state (tools/commands/resources auto-cleared)
+            updateServer({
+                name: serverName,
+                type: 'disabled',
+                config: client.config,
+            });
+        }
+        else {
+            // Enabling: persist enabled state to disk first
+            setMcpServerEnabled(serverName, true);
+            // Mark as pending and reconnect
+            updateServer({
+                name: serverName,
+                type: 'pending',
+                config: client.config,
+            });
+            // Reconnect the server
+            const result = await reconnectMcpServerImpl(serverName, client.config);
+            onConnectionAttempt(result);
+        }
+    }, [store, updateServer, onConnectionAttempt]);
+    return { reconnectMcpServer, toggleMcpServer };
+}
+function getTransportDisplayName(type) {
+    switch (type) {
+        case 'http':
+            return 'HTTP';
+        case 'ws':
+        case 'ws-ide':
+            return 'WebSocket';
+        default:
+            return 'SSE';
+    }
+}