@iblai/web-containers 1.57.0 → 1.58.1

package/dist/cjs/components/modals/edit-mentor-modal/tabs/mcp-tab/use-mcp-server-actions.js

@@ -0,0 +1,744 @@
+'use strict';
+
+var React = require('react');
+var dataLayer = require('@iblai/data-layer');
+var sonner = require('sonner');
+var useLocalStorage = require('../../../../../hooks/use-local-storage.js');
+var context = require('../../../../../i18n/context.js');
+require('../../../../../packages/i18n/dist/index.esm.js');
+var mcpConnectorHelpers = require('./mcp-connector-helpers.js');
+
+const skipRefetch = () => Promise.resolve();
+function useMcpServerActions({ tenantKey, username, mentorId, refetchServers, softUserScopeConnectFailure = false, onConnectNotConfigured, }) {
+    var _a;
+    const t = context.useT();
+    const [togglingServerIds, setTogglingServerIds] = React.useState(() => new Set());
+    const [connectingServiceIds, setConnectingServiceIds] = React.useState(() => new Set());
+    const [disconnectingServiceIds, setDisconnectingServiceIds] = React.useState(() => new Set());
+    const [deletingServerId, setDeletingServerId] = React.useState(null);
+    const [, setPendingOAuthServer, removePendingOAuthServer] = useLocalStorage.useLocalStorage('oauth_pending_server', null);
+    // Tracks in-flight OAuth cleanup callbacks so they fire on unmount, not just
+    // on successful completion / timeout / popup-closed paths inside
+    // `handleConnectOAuth`. Without this, navigating away mid-flow would leak
+    // the `storage` / `message` / `focus` window listeners until the 5-minute
+    // safety timer eventually fires.
+    const oauthCleanupsRef = React.useRef(new Set());
+    // The callback page's answer reaches every flow for the service, whichever
+    // tab it came from, so a second flow for one connector would create its
+    // connection twice.
+    const signInsInFlightRef = React.useRef(new Set());
+    React.useEffect(() => () => {
+        oauthCleanupsRef.current.forEach((fn) => fn());
+        oauthCleanupsRef.current.clear();
+    }, []);
+    const { data: mentorSettings, isLoading: isSettingsLoading, refetch: refetchMentorSettings, } = dataLayer.useGetMentorSettingsQuery({
+        mentor: mentorId,
+        org: tenantKey,
+        // @ts-expect-error userId is not part of useGetMentorSettingsQuery Query definition
+        userId: username,
+    }, { skip: !username });
+    const { data: connectedServices, refetch: refetchConnected } = dataLayer.useGetConnectedServicesQuery({ org: tenantKey, userId: username }, { skip: !tenantKey || !username });
+    const { data: mcpServerConnections, refetch: refetchMCPServerConnections } = dataLayer.useGetMCPServerConnectionsQuery({ org: tenantKey, userId: username }, { skip: !tenantKey || !username });
+    const [createMCPServer] = dataLayer.useCreateMCPServerMutation();
+    const [updateMCPServer] = dataLayer.useUpdateMCPServerMutation();
+    const [deleteMCPServer] = dataLayer.useDeleteMCPServerMutation();
+    const [editMentorJson] = dataLayer.useEditMentorJsonMutation();
+    const [startOAuthFlow] = dataLayer.useLazyStartOAuthFlowQuery();
+    const [disconnectService] = dataLayer.useDisconnectServiceMutation();
+    const [createMCPServerConnection] = dataLayer.useCreateMCPServerConnectionMutation();
+    // Field-level RBAC blanks mcp_servers for users who may not read it — to []
+    // on the settings endpoint, flagged by permissions.field.mcp_servers.read ===
+    // false — so an empty list alone does not mean "no servers attached".
+    const attachmentsKnown = React.useMemo(() => {
+        var _a, _b, _c;
+        if (!mentorSettings || typeof mentorSettings !== 'object')
+            return false;
+        const settings = mentorSettings;
+        return (Array.isArray(settings.mcp_servers) &&
+            ((_c = (_b = (_a = settings.permissions) === null || _a === void 0 ? void 0 : _a.field) === null || _b === void 0 ? void 0 : _b.mcp_servers) === null || _c === void 0 ? void 0 : _c.read) !== false);
+    }, [mentorSettings]);
+    const activeMcpServerIds = React.useMemo(() => {
+        if (!mentorSettings || typeof mentorSettings !== 'object')
+            return [];
+        const maybeServers = mentorSettings.mcp_servers;
+        if (!Array.isArray(maybeServers))
+            return [];
+        return maybeServers
+            .map((entry) => {
+            if (typeof entry === 'number' && Number.isFinite(entry))
+                return entry;
+            if (typeof entry === 'object' && entry !== null && 'id' in entry) {
+                const id = entry.id;
+                if (typeof id === 'number')
+                    return id;
+            }
+            return null;
+        })
+            .filter((id) => typeof id === 'number' && Number.isFinite(id));
+    }, [mentorSettings]);
+    const toolsKnown = React.useMemo(() => !!mentorSettings &&
+        typeof mentorSettings === 'object' &&
+        Array.isArray(mentorSettings.mentor_tools), [mentorSettings]);
+    // mentor_tools is an array of objects like: [{ name: "MCP", slug: "mcp", ... }]
+    const currentToolSlugs = React.useMemo(() => {
+        if (!mentorSettings || typeof mentorSettings !== 'object')
+            return [];
+        const maybeTools = mentorSettings.mentor_tools;
+        if (!Array.isArray(maybeTools))
+            return [];
+        return maybeTools
+            .map((tool) => {
+            if (typeof tool === 'object' && tool !== null && 'slug' in tool) {
+                const slug = tool.slug;
+                if (typeof slug === 'string')
+                    return slug;
+            }
+            return null;
+        })
+            .filter((slug) => typeof slug === 'string');
+    }, [mentorSettings]);
+    const fieldPermissions = (_a = mentorSettings === null || mentorSettings === void 0 ? void 0 : mentorSettings.permissions) === null || _a === void 0 ? void 0 : _a.field;
+    const isOAuthServerConnected = React.useCallback((server) => {
+        const connection = mcpConnectorHelpers.findMCPServerConnection(mcpServerConnections === null || mcpServerConnections === void 0 ? void 0 : mcpServerConnections.results, server.id, username, mentorId);
+        return !!connection && mcpConnectorHelpers.connectionHasSignIn(connection);
+    }, [mcpServerConnections, username, mentorId]);
+    const hasConnectionForScope = React.useCallback((serverId, scope) => mcpConnectorHelpers.connectionForScopeExists(mcpServerConnections === null || mcpServerConnections === void 0 ? void 0 : mcpServerConnections.results, serverId, scope, username, mentorId), [mcpServerConnections, username, mentorId]);
+    const getConnectedServiceId = React.useCallback((server) => {
+        var _a;
+        const connection = mcpConnectorHelpers.findMCPServerConnection(mcpServerConnections === null || mcpServerConnections === void 0 ? void 0 : mcpServerConnections.results, server.id, username, mentorId);
+        return (_a = connection === null || connection === void 0 ? void 0 : connection.connected_service) !== null && _a !== void 0 ? _a : null;
+    }, [mcpServerConnections, username, mentorId]);
+    /** The current user's own sign-in for the server's OAuth service, if any. */
+    const getSignedInServiceId = React.useCallback((server) => {
+        var _a;
+        const oauthData = server.oauth_service_data;
+        if (!oauthData || !Array.isArray(connectedServices))
+            return null;
+        const service = connectedServices.find((cs) => cs.provider === oauthData.oauth_provider && cs.service === oauthData.name);
+        return (_a = service === null || service === void 0 ? void 0 : service.id) !== null && _a !== void 0 ? _a : null;
+    }, [connectedServices]);
+    /** Whether a connected service belongs to the current user (only theirs can be deleted). */
+    const ownsConnectedService = React.useCallback((connectedServiceId) => connectedServiceId !== null &&
+        Array.isArray(connectedServices) &&
+        connectedServices.some((cs) => cs.id === connectedServiceId), [connectedServices]);
+    const getConnectionId = React.useCallback((server) => {
+        var _a;
+        const connection = mcpConnectorHelpers.findMCPServerConnection(mcpServerConnections === null || mcpServerConnections === void 0 ? void 0 : mcpServerConnections.results, server.id, username, mentorId);
+        return (_a = connection === null || connection === void 0 ? void 0 : connection.id) !== null && _a !== void 0 ? _a : null;
+    }, [mcpServerConnections, username, mentorId]);
+    const updateMCPServers = React.useCallback(async (serverIds, options) => {
+        if (!mentorId)
+            throw new Error('Invalid mentor ID');
+        const uniqueIds = [...new Set(serverIds.filter((id) => Number.isFinite(id) && id > 0))];
+        const requestBody = { mcp_servers: uniqueIds };
+        if ((options === null || options === void 0 ? void 0 : options.toolSlugs) !== undefined) {
+            requestBody.tool_slugs = options.toolSlugs;
+        }
+        if ((options === null || options === void 0 ? void 0 : options.canUseTools) !== undefined) {
+            requestBody.can_use_tools = options.canUseTools;
+        }
+        await editMentorJson({
+            mentorId,
+            org: tenantKey,
+            requestBody,
+            userId: username,
+        }).unwrap();
+    }, [mentorId, tenantKey, username, editMentorJson]);
+    // Taking the last server off the agent also drops the 'mcp' tool slug, so the switch,
+    // Disconnect and Delete all leave the agent's tools matching its servers.
+    const detachServerFromAgent = React.useCallback(async (serverId) => {
+        const updatedIds = activeMcpServerIds.filter((id) => id !== serverId);
+        if (updatedIds.length === 0 && currentToolSlugs.includes('mcp')) {
+            const updatedToolSlugs = currentToolSlugs.filter((slug) => slug !== 'mcp');
+            await updateMCPServers(updatedIds, {
+                toolSlugs: updatedToolSlugs,
+                canUseTools: updatedToolSlugs.length > 0,
+            });
+        }
+        else {
+            await updateMCPServers(updatedIds);
+        }
+    }, [activeMcpServerIds, currentToolSlugs, updateMCPServers]);
+    const handleToggleConnector = React.useCallback(async (serverId, serverName, isActive, options) => {
+        var _a, _b;
+        if (!Number.isFinite(serverId) || serverId <= 0) {
+            sonner.toast.error(t('mcpTabConnectorManagementContent.invalidServerId'));
+            return false;
+        }
+        setTogglingServerIds((prev) => new Set(prev).add(serverId));
+        try {
+            const currentIds = Array.isArray(activeMcpServerIds) ? activeMcpServerIds : [];
+            const updatedIds = isActive
+                ? currentIds.includes(serverId)
+                    ? currentIds
+                    : [...currentIds, serverId]
+                : currentIds.filter((id) => id !== serverId);
+            /* istanbul ignore next -- @preserve optimization path, tested via toggle tests */
+            if (updatedIds.length === currentIds.length && isActive && currentIds.includes(serverId)) {
+                return true;
+            }
+            const hasMcpInToolSlugs = currentToolSlugs.includes('mcp');
+            if (isActive) {
+                // Enabling any connector needs the 'mcp' tool slug and can_use_tools on.
+                if (!hasMcpInToolSlugs) {
+                    const updatedToolSlugs = [...currentToolSlugs, 'mcp'];
+                    await updateMCPServers(updatedIds, {
+                        toolSlugs: updatedToolSlugs,
+                        canUseTools: true,
+                    });
+                }
+                else {
+                    await updateMCPServers(updatedIds, {
+                        canUseTools: true,
+                    });
+                }
+            }
+            else {
+                await detachServerFromAgent(serverId);
+            }
+            await refetchMentorSettings();
+            if (options === null || options === void 0 ? void 0 : options.quiet)
+                return true;
+            sonner.toast.success(isActive
+                ? t('mcpTabConnectorManagementContent.serverActivated', { serverName })
+                : t('mcpTabConnectorManagementContent.serverDeactivated', { serverName }));
+            return true;
+        }
+        catch (error) {
+            const err = error;
+            const msg = ((_a = err === null || err === void 0 ? void 0 : err.data) === null || _a === void 0 ? void 0 : _a.detail) || ((_b = err === null || err === void 0 ? void 0 : err.data) === null || _b === void 0 ? void 0 : _b.error) || (err === null || err === void 0 ? void 0 : err.message) || '';
+            if (msg.includes('does not exist') || msg.includes('not accessible')) {
+                sonner.toast.error(t('mcpTabConnectorManagementContent.serverNotAccessible', { serverName }));
+            }
+            else {
+                sonner.toast.error(isActive
+                    ? t('mcpTabConnectorManagementContent.failedToActivate', { serverName, msg })
+                    : t('mcpTabConnectorManagementContent.failedToDeactivate', { serverName, msg }));
+            }
+            return false;
+        }
+        finally {
+            setTogglingServerIds((prev) => {
+                const next = new Set(prev);
+                next.delete(serverId);
+                return next;
+            });
+        }
+    }, [
+        activeMcpServerIds,
+        currentToolSlugs,
+        updateMCPServers,
+        detachServerFromAgent,
+        refetchMentorSettings,
+        t,
+    ]);
+    /** Creates or updates a server; returns whether it was saved. New servers are auto-attached. */
+    const saveConnector = React.useCallback(async (connector, options = {}) => {
+        var _a, _b;
+        const { editingServer, onSaved } = options;
+        if (!tenantKey || !username) {
+            sonner.toast.error(t('mcpTabConnectorManagementContent.missingRequiredParams'));
+            return false;
+        }
+        try {
+            const hasFileImage = connector.image instanceof File;
+            const trimmedCredentials = (_a = connector.credentials) === null || _a === void 0 ? void 0 : _a.trim();
+            const authType = (_b = connector.authType) !== null && _b !== void 0 ? _b : (trimmedCredentials ? 'token' : 'none');
+            const resolvedTransport = mcpConnectorHelpers.normalizeTransportValue(connector.transport);
+            const basePayload = {
+                name: connector.name,
+                url: connector.url || `https://api.${connector.name.toLowerCase()}.com/mcp`,
+                transport: resolvedTransport,
+                auth_type: authType,
+                description: connector.description || '',
+                // For edits, undefined credentials means "keep the existing ones".
+                ...(trimmedCredentials !== undefined && {
+                    credentials: trimmedCredentials,
+                }),
+                ...(connector.authScope && { auth_scope: connector.authScope }),
+                ...(connector.mentor !== undefined && { mentor: connector.mentor }),
+                ...(connector.userCanDisable !== undefined && {
+                    user_can_disable: connector.userCanDisable,
+                }),
+            };
+            /* istanbul ignore next -- @preserve update path tested via ConnectorDialogs integration */
+            if (editingServer) {
+                const args = {
+                    id: editingServer.id,
+                    org: tenantKey,
+                    userId: username,
+                    ...(hasFileImage
+                        ? {
+                            formData: mcpConnectorHelpers.createMCPServerFormData({
+                                ...basePayload,
+                                image: connector.image,
+                            }),
+                        }
+                        : { body: basePayload }),
+                };
+                await updateMCPServer(args).unwrap();
+                sonner.toast.success(t('mcpTabConnectorManagementContent.connectorUpdated', { name: connector.name }));
+            }
+            else {
+                const args = {
+                    org: tenantKey,
+                    userId: username,
+                    ...(hasFileImage
+                        ? {
+                            formData: mcpConnectorHelpers.createMCPServerFormData({
+                                ...basePayload,
+                                image: connector.image,
+                            }),
+                        }
+                        : { body: basePayload }),
+                };
+                const newServer = await createMCPServer(args).unwrap();
+                sonner.toast.success(t('mcpTabConnectorManagementContent.connectorAdded', { name: connector.name }));
+                try {
+                    const newId = Number(newServer.id);
+                    if (Number.isFinite(newId)) {
+                        // The PUT replaces the whole list: built from unread (redacted or unloaded)
+                        // settings it would drop every other server and tool from the agent.
+                        if (!attachmentsKnown || !toolsKnown) {
+                            throw new Error('Agent attachments are unknown');
+                        }
+                        const updatedIds = [...activeMcpServerIds, newId];
+                        const hasMcpInToolSlugs = currentToolSlugs.includes('mcp');
+                        if (!hasMcpInToolSlugs) {
+                            const updatedToolSlugs = [...currentToolSlugs, 'mcp'];
+                            await updateMCPServers(updatedIds, {
+                                toolSlugs: updatedToolSlugs,
+                                canUseTools: true,
+                            });
+                        }
+                        else {
+                            await updateMCPServers(updatedIds, {
+                                canUseTools: true,
+                            });
+                        }
+                        await refetchMentorSettings();
+                    }
+                }
+                catch (_c) {
+                    sonner.toast.warning(t('mcpTabConnectorManagementContent.connectorNotActivated', { name: connector.name }));
+                }
+            }
+            onSaved === null || onSaved === void 0 ? void 0 : onSaved();
+            await refetchServers();
+            return true;
+        }
+        catch (_d) {
+            sonner.toast.error(editingServer
+                ? t('mcpTabConnectorManagementContent.failedToUpdateConnector', {
+                    name: connector.name,
+                })
+                : t('mcpTabConnectorManagementContent.failedToAddConnector', { name: connector.name }));
+            return false;
+        }
+    }, [
+        tenantKey,
+        username,
+        attachmentsKnown,
+        toolsKnown,
+        activeMcpServerIds,
+        currentToolSlugs,
+        createMCPServer,
+        updateMCPServer,
+        updateMCPServers,
+        refetchServers,
+        refetchMentorSettings,
+    ]);
+    const handleConnectOAuth = React.useCallback(async (server) => {
+        var _a;
+        if (!tenantKey || !username || !server.oauth_service_data) {
+            sonner.toast.error(t('mcpTabConnectorManagementContent.missingOAuthParams'));
+            return;
+        }
+        const serviceKey = `server-${server.id}`;
+        if (signInsInFlightRef.current.has(serviceKey))
+            return;
+        signInsInFlightRef.current.add(serviceKey);
+        // Opened before the first await, while the click still counts: the tab
+        // shows at once and pop-up blockers let it through. It keeps its opener,
+        // which the callback page posts the result to.
+        const tab = window.open('', '_blank');
+        const closeTab = () => tab === null || tab === void 0 ? void 0 : tab.close();
+        const oauthData = server.oauth_service_data;
+        const { oauth_provider: provider, name } = oauthData;
+        const serverId = server.id;
+        const oauthDisplayName = oauthData.display_name || name;
+        // The agent's own override, else the connector's: the connection's scope.
+        const authScope = (_a = server.effective_auth_scope) !== null && _a !== void 0 ? _a : server.auth_scope;
+        const softCreateFailureMessage = softUserScopeConnectFailure && (authScope || 'user') === 'user'
+            ? t('mcpServersMenu.signedInReadyNextMessage', { name: oauthDisplayName })
+            : undefined;
+        setPendingOAuthServer({
+            serverId,
+            provider,
+            service: name,
+            timestamp: Date.now(),
+        });
+        setConnectingServiceIds((prev) => new Set(prev).add(serviceKey));
+        // State the cleanup closure references. Declared before the first
+        // `await` so we can register cleanup synchronously — guaranteeing an
+        // unmount mid-flow tears down listeners, intervals, and timers.
+        let pollCount = 0;
+        const maxPolls = 60;
+        let pollInterval = null;
+        let popupCheckInterval = null;
+        let isCreatingConnection = false;
+        // Listener handlers — reassigned with real implementations once the
+        // OAuth URL resolves. Default noops let cleanup safely call
+        // removeEventListener even if we never reached addEventListener (e.g.
+        // unmount before startOAuthFlow resolves).
+        let handleFocus = () => { };
+        let handleStorageChange = () => { };
+        let handleMessage = () => { };
+        // Idempotent — tracked in `oauthCleanupsRef` so unmount can also drive it.
+        let cleanedUp = false;
+        // Set while the connection is being created from a completed sign-in.
+        let creating = false;
+        const stopListening = () => {
+            if (pollInterval)
+                clearInterval(pollInterval);
+            if (popupCheckInterval)
+                clearInterval(popupCheckInterval);
+            pollInterval = null;
+            popupCheckInterval = null;
+            window.removeEventListener('focus', handleFocus);
+            window.removeEventListener('storage', handleStorageChange);
+            window.removeEventListener('message', handleMessage);
+        };
+        // The connecting key stays until the connection exists, so "Connecting..."
+        // gives way to Connected, never back to Connect while the connection and
+        // its refetch settle.
+        const cleanup = () => {
+            if (cleanedUp)
+                return;
+            cleanedUp = true;
+            oauthCleanupsRef.current.delete(cleanup);
+            signInsInFlightRef.current.delete(serviceKey);
+            stopListening();
+            setConnectingServiceIds((prev) => {
+                const next = new Set(prev);
+                next.delete(serviceKey);
+                return next;
+            });
+            removePendingOAuthServer();
+            isCreatingConnection = false;
+        };
+        oauthCleanupsRef.current.add(cleanup);
+        try {
+            const result = await startOAuthFlow({
+                org: tenantKey,
+                userId: username,
+                provider,
+                service: name,
+            }).unwrap();
+            if (!result.auth_url)
+                throw new Error('No authorization URL returned');
+            // Bail if the flow was already torn down while we awaited the auth URL
+            // (e.g. the component unmounted). `cleanup` has run and been dropped
+            // from `oauthCleanupsRef`, so anything registered past this point —
+            // listeners, intervals, timers — would leak with nothing left to
+            // remove it.
+            if (cleanedUp) {
+                closeTab();
+                return;
+            }
+            const authUrl = result.auth_url;
+            const popup = tab !== null && tab !== void 0 ? tab : window.open(authUrl, '_blank');
+            // A tab closed while the address was on its way means the sign-in was
+            // given up; the closed-tab watcher below ends the flow.
+            if (tab && !tab.closed)
+                tab.location.href = authUrl;
+            const doCreateConnection = async (connectedServiceId) => {
+                creating = true;
+                try {
+                    const result = await mcpConnectorHelpers.createOAuthConnection({
+                        connectedServiceId,
+                        isCreatingConnection,
+                        createMCPServerConnection,
+                        tenantKey,
+                        username,
+                        serverId,
+                        authScope,
+                        mentorId,
+                        oauthDisplayName,
+                        refetchFeatured: refetchServers,
+                        refetchMy: skipRefetch,
+                        refetchConnected,
+                        refetchMCPServerConnections,
+                        refetchMentorSettings,
+                        softCreateFailureMessage,
+                        successMessage: t('mcpTabConnectorManagementContent.connectedSuccessfully', {
+                            name: oauthDisplayName,
+                        }),
+                        formatErrorMessage: (detail) => t('mcpTabConnectorManagementContent.failedToCreateConnection', {
+                            detail: detail || t('mcpTabConnectorManagementContent.unknownError'),
+                        }),
+                    }, 
+                    /* istanbul ignore next -- @preserve success callback, tested via createOAuthConnection */
+                    () => {
+                        isCreatingConnection = false;
+                    }, 
+                    /* istanbul ignore next -- @preserve error callback, tested via createOAuthConnection */
+                    () => {
+                        isCreatingConnection = false;
+                    });
+                    if (result) {
+                        isCreatingConnection = true;
+                    }
+                    return result;
+                }
+                finally {
+                    creating = false;
+                }
+            };
+            const checkConnection = async () => {
+                const earlyCheck = mcpConnectorHelpers.determineCheckConnectionAction(isCreatingConnection, null, false, pollCount, maxPolls);
+                if (earlyCheck.action === 'skip')
+                    return;
+                try {
+                    const connectedServiceId = await mcpConnectorHelpers.checkOAuthConnectionComplete(refetchConnected, provider, name);
+                    /* istanbul ignore next -- @preserve callback wrapper, logic tested via helper */
+                    if (connectedServiceId) {
+                        const result = await mcpConnectorHelpers.executeConnectionFoundCleanup({
+                            connectedServiceId,
+                            doCreateConnection,
+                            pollCount,
+                            maxPolls,
+                            cleanup,
+                        });
+                        if (result.cleaned) {
+                            return;
+                        }
+                    }
+                    await refetchServers();
+                    pollCount++;
+                    mcpConnectorHelpers.executeMaxPollsCleanup({ pollCount, maxPolls, cleanup });
+                }
+                catch (_a) {
+                    // The interval retries on its next tick.
+                }
+            };
+            handleFocus = () => checkConnection();
+            /* istanbul ignore next -- @preserve callback wrapper, logic tested via helper */
+            handleMessage = async (event) => {
+                const { executed } = await mcpConnectorHelpers.executeHandleMessageCallback({
+                    event,
+                    expectedOrigin: window.location.origin,
+                    provider,
+                    serviceName: name,
+                    // Stop listening at once, but keep the connecting key until the create settles.
+                    cleanup: stopListening,
+                    doCreateConnection,
+                });
+                if (executed)
+                    cleanup();
+            };
+            handleStorageChange = async (e) => {
+                const result = mcpConnectorHelpers.processOAuthStorageEvent(e, provider, name);
+                if (result) {
+                    if (result.isMatch) {
+                        stopListening();
+                        await doCreateConnection(result.connectedServiceId);
+                        cleanup();
+                    }
+                    else {
+                        await checkConnection();
+                    }
+                }
+                else if (e.key === 'oauth_connection_complete') {
+                    /* istanbul ignore next */
+                    await checkConnection();
+                }
+            };
+            window.addEventListener('storage', handleStorageChange);
+            window.addEventListener('message', handleMessage);
+            window.addEventListener('focus', handleFocus);
+            pollInterval = setInterval(checkConnection, 5000);
+            setTimeout(cleanup, 5 * 60 * 1000);
+            if (popup) {
+                popupCheckInterval = setInterval(() => {
+                    if (popup.closed) {
+                        if (popupCheckInterval)
+                            clearInterval(popupCheckInterval);
+                        popupCheckInterval = null;
+                        // Grace period for OAuth callback/redirect to complete
+                        setTimeout(() => {
+                            if (!isCreatingConnection && !creating) {
+                                cleanup();
+                            }
+                        }, 10000);
+                    }
+                }, 2000);
+            }
+        }
+        catch (error) {
+            closeTab();
+            // 400 from the start endpoint: no sign-in app for this organization.
+            const status = error === null || error === void 0 ? void 0 : error.status;
+            if (status === 400 && (onConnectNotConfigured === null || onConnectNotConfigured === void 0 ? void 0 : onConnectNotConfigured(server))) {
+                cleanup();
+                return;
+            }
+            sonner.toast.error(t('mcpTabConnectorManagementContent.failedToConnect', {
+                name: oauthData.display_name || name,
+            }));
+            cleanup();
+        }
+    }, [
+        tenantKey,
+        username,
+        onConnectNotConfigured,
+        startOAuthFlow,
+        createMCPServerConnection,
+        refetchServers,
+        refetchConnected,
+        refetchMCPServerConnections,
+        refetchMentorSettings,
+        mentorId,
+        softUserScopeConnectFailure,
+        setPendingOAuthServer,
+        removePendingOAuthServer,
+    ]);
+    const handleDisconnectOAuth = React.useCallback(async (server, { detachFromAgent = true, connectedServiceId: signedInServiceId = null, } = {}) => {
+        var _a, _b, _c;
+        const validation = mcpConnectorHelpers.validateDisconnectOAuthParams(tenantKey, username, (_a = getConnectedServiceId(server)) !== null && _a !== void 0 ? _a : signedInServiceId);
+        /* istanbul ignore next -- @preserve validation error branch */
+        if (!validation.isValid) {
+            sonner.toast.error(validation.error || 'Validation failed');
+            return;
+        }
+        const connectedServiceId = validation.connectedServiceId;
+        setDisconnectingServiceIds((prev) => new Set(prev).add(server.id));
+        try {
+            // Delete the sign-in first: detaching changes the agent for everyone, so it must
+            // not happen when the sign-in could not be removed.
+            await disconnectService({
+                org: tenantKey,
+                userId: username,
+                id: connectedServiceId,
+            }).unwrap();
+            if (detachFromAgent) {
+                try {
+                    await detachServerFromAgent(server.id);
+                }
+                catch (error) {
+                    const err = error;
+                    sonner.toast.error(t('mcpTabConnectorManagementContent.failedToDeactivate', {
+                        serverName: server.name,
+                        msg: ((_b = err === null || err === void 0 ? void 0 : err.data) === null || _b === void 0 ? void 0 : _b.detail) || ((_c = err === null || err === void 0 ? void 0 : err.data) === null || _c === void 0 ? void 0 : _c.error) || (err === null || err === void 0 ? void 0 : err.message) || '',
+                    }));
+                }
+            }
+            await Promise.all([
+                refetchServers(),
+                refetchConnected(),
+                refetchMCPServerConnections(),
+                refetchMentorSettings(),
+            ]);
+            sonner.toast.success(t('mcpTabConnectorManagementContent.serviceDisconnected'));
+        }
+        catch (_d) {
+            sonner.toast.error(t('mcpTabConnectorManagementContent.failedToDisconnect'));
+        }
+        finally {
+            setDisconnectingServiceIds((prev) => {
+                const next = new Set(prev);
+                next.delete(server.id);
+                return next;
+            });
+        }
+    }, [
+        tenantKey,
+        username,
+        getConnectedServiceId,
+        detachServerFromAgent,
+        disconnectService,
+        refetchServers,
+        refetchConnected,
+        refetchMCPServerConnections,
+        refetchMentorSettings,
+    ]);
+    /** Deletes the server, then removes it from the agent. Resolves true once the server is deleted. */
+    const deleteServer = React.useCallback(async (serverId, serverName) => {
+        if (!tenantKey || !username) {
+            sonner.toast.error(t('mcpTabConnectorManagementContent.missingRequiredParams'));
+            return false;
+        }
+        setDeletingServerId(serverId);
+        try {
+            await deleteMCPServer({
+                id: serverId,
+                org: tenantKey,
+                userId: username,
+            }).unwrap();
+            sonner.toast.success(t('mcpTabConnectorManagementContent.connectorRemoved', { serverName }));
+            await refetchServers();
+            // Without readable attachments activeMcpServerIds is empty, and writing it
+            // back would detach every server from the agent.
+            if (attachmentsKnown) {
+                try {
+                    await detachServerFromAgent(serverId);
+                    await refetchMentorSettings();
+                }
+                catch (_a) {
+                    sonner.toast.warning(t('mcpTabConnectorManagementContent.connectorDeletedStillActive', { serverName }));
+                }
+            }
+            return true;
+        }
+        catch (_b) {
+            sonner.toast.error(t('mcpTabConnectorManagementContent.failedToRemoveConnector', { serverName }));
+            return false;
+        }
+        finally {
+            setDeletingServerId(null);
+        }
+    }, [
+        tenantKey,
+        username,
+        attachmentsKnown,
+        deleteMCPServer,
+        detachServerFromAgent,
+        refetchServers,
+        refetchMentorSettings,
+        t,
+    ]);
+    const refetchAfterOAuth = React.useCallback(async () => {
+        await Promise.all([refetchServers(), refetchMCPServerConnections(), refetchMentorSettings()]);
+    }, [refetchServers, refetchMCPServerConnections, refetchMentorSettings]);
+    return {
+        mentorSettings,
+        isSettingsLoading,
+        attachmentsKnown,
+        activeMcpServerIds,
+        currentToolSlugs,
+        fieldPermissions,
+        isOAuthServerConnected,
+        hasConnectionForScope,
+        getConnectedServiceId,
+        getSignedInServiceId,
+        ownsConnectedService,
+        getConnectionId,
+        updateMCPServers,
+        handleToggleConnector,
+        saveConnector,
+        deleteServer,
+        handleConnectOAuth,
+        handleDisconnectOAuth,
+        refetchAfterOAuth,
+        refetchMentorSettings,
+        refetchConnected,
+        refetchMCPServerConnections,
+        togglingServerIds,
+        connectingServiceIds,
+        disconnectingServiceIds,
+        deletingServerId,
+    };
+}
+
+exports.useMcpServerActions = useMcpServerActions;
+//# sourceMappingURL=use-mcp-server-actions.js.map