📱 fix: Open Sign-In and External Links From iOS Home-Screen Apps (#16077)

* 📱 fix: Open Sign-In and External Links From iOS Home-Screen Apps

Sign-in prompts, the MCP OAuth Continue buttons and the account menu links opened with window.open and a noopener,noreferrer features string. WebKit treats a features string as a popup-window request, which an iOS home-screen app cannot open, and the chat sign-in also awaited its CSRF bind before opening, outside the tap. Links now open through a target=_blank link with rel=noopener noreferrer, and the chat prompt binds when it appears so the tap opens the provider synchronously.

* fix: Keep sign-in closed until its CSRF bind lands, and surface builder OAuth in its dialog

A tap while the chat prompt's bind was still in flight could open the provider before its CSRF cookie existed, and an Action callback has no fallback without that cookie; the button now stays disabled until the bind lands. The MCP builder card opened the authorization URL only after its initialize request, which iOS home-screen apps refuse and which left the card with no way to continue; it now shows the MCP OAuth dialog instead.

* fix: Let the tapped prompt own the CSRF binding, and show only the card's live OAuth flow

Live sign-in prompts share one CSRF cookie per callback path, so the last prompt to bind owned it; a tap now re-binds its own prompt right after opening the provider. The builder card kept a local copy of the authorization URL that outlived its flow and could reopen it on a later initialization; it now shows the manager's shared flow URL, cleared when the flow ends, and only for a flow the card itself started.
This commit is contained in:
Danny Avila 2026-09-19 08:09:25 -04:00 • committed by GitHub
parent c7665ab1ae
commit 038903abc0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
11 changed files with 440 additions and 42 deletions

View file

@ -10,10 +10,10 @@ import {
} from 'librechat-data-provider';
import type { TAttachment, PartMetadata } from 'librechat-data-provider';
import { useLocalize, useProgress, useExpandCollapse, useLazyCollapseBody } from '~/hooks';
import { cn, getToolDisplayLabel, logger, openInNewTab } from '~/utils';
import { ToolIcon, getToolIconType, isError } from './ToolOutput';
import { useMCPIconMap, useMCPServerNames } from '~/hooks/MCP';
import { resolveToolCallPhase } from '~/utils/toolCallPhase';
import { cn, getToolDisplayLabel, logger } from '~/utils';
import { toolPanelSpacingClassName } from './disclosure';
import { useToolCallIntent } from './Parts/intent';
import { AttachmentGroup } from './Parts';
@ -54,6 +54,7 @@ export default function ToolCall({
}) {
const localize = useLocalize();
const [oauthError, setOAuthError] = useState<string | null>(null);
const [oauthBinding, setOAuthBinding] = useState<'pending' | 'bound' | 'failed'>('pending');
const autoExpand = useRecoilValue(store.autoExpandTools);
const hasOutput = (output?.length ?? 0) > 0;
const [showInfo, setShowInfo] = useState(() => autoExpand && hasOutput);
@ -139,24 +140,23 @@ export default function ToolCall({
return match?.[1] || '';
}, [parsedAuthUrl, isMCPToolCall]);
const handleOAuthClick = useCallback(async () => {
if (!auth) {
return;
/**
* Sets the CSRF cookie the OAuth callback checks when the provider redirects back, or returns
* null when this prompt has nothing to bind.
*/
const bindOAuth = useCallback((): Promise<void> | null => {
const bindsMCP = isMCPToolCall && mcpServerName.length > 0;
if (!bindsMCP && !actionId) {
return null;
}
setOAuthError(null);
try {
if (isMCPToolCall && mcpServerName) {
return (async () => {
if (bindsMCP) {
await dataService.bindMCPOAuth(mcpServerName);
} else if (actionId) {
} else {
await dataService.bindActionOAuth(actionId);
}
} catch (e) {
logger.error('Failed to bind OAuth CSRF cookie', e);
setOAuthError(localize('com_ui_oauth_error_generic'));
return;
}
window.open(auth, '_blank', 'noopener,noreferrer');
}, [auth, isMCPToolCall, mcpServerName, actionId, localize]);
})();
}, [isMCPToolCall, mcpServerName, actionId]);
const hasError = (typeof output === 'string' && isError(output)) || runStepStatus === 'failed';
/**
@ -216,6 +216,72 @@ export default function ToolCall({
isSubmitting,
hasError,
});
const showOAuth = Boolean(auth) && phase === 'running';
/**
* Binds when the sign-in prompt appears instead of on tap, so the tap opens the provider
* synchronously: an iOS home-screen app drops a tab opened after an awaited request. The button
* stays disabled until the bind lands, so the provider cannot redirect back before its cookie.
*/
useEffect(() => {
if (!showOAuth) {
return;
}
const binding = bindOAuth();
if (binding == null) {
setOAuthBinding('bound');
return;
}
let active = true;
setOAuthBinding('pending');
binding.then(
() => {
if (active) {
setOAuthBinding('bound');
}
},
(error: unknown) => {
logger.error('Failed to bind OAuth CSRF cookie', error);
if (active) {
setOAuthBinding('failed');
}
},
);
return () => {
active = false;
};
}, [showOAuth, auth, bindOAuth]);
const handleOAuthClick = useCallback(() => {
if (!auth || oauthBinding === 'pending') {
return;
}
if (oauthBinding === 'bound') {
setOAuthError(null);
openInNewTab(auth);
/**
* Live prompts share one CSRF cookie per callback path, so the last prompt to bind owns it.
* The tapped prompt claims it again after opening; the provider cannot redirect back before
* the user signs in, and the session cookie from the earlier bind covers a faster callback.
*/
bindOAuth()?.catch((error: unknown) => {
logger.error('Failed to bind OAuth CSRF cookie', error);
});
return;
}
setOAuthError(localize('com_ui_oauth_error_generic'));
setOAuthBinding('pending');
(bindOAuth() ?? Promise.resolve()).then(
() => {
setOAuthBinding('bound');
setOAuthError(null);
},
(error: unknown) => {
logger.error('Failed to bind OAuth CSRF cookie', error);
setOAuthBinding('failed');
},
);
}, [auth, oauthBinding, bindOAuth, localize]);
const handleToggleInfo = useCallback(() => {
mountBody();
@ -329,13 +395,15 @@ export default function ToolCall({
)}
</div>
</div>
{auth != null && auth && phase === 'running' && (
{showOAuth && (
<div className="flex w-full flex-col gap-2.5">
<div className="mb-1 mt-2">
<Button
className="inline-flex items-center justify-center rounded-xl px-4 py-2 text-sm font-medium"
variant="default"
rel="noopener noreferrer"
disabled={oauthBinding === 'pending'}
aria-busy={oauthBinding === 'pending'}
onClick={handleOAuthClick}
>
{localize('com_ui_sign_in_to_domain', { 0: authDomain })}

View file

@ -1,9 +1,10 @@
import React from 'react';
import { RecoilRoot } from 'recoil';
import { Tools, Constants } from 'librechat-data-provider';
import { render, screen, fireEvent } from '@testing-library/react';
import { Tools, Constants, dataService } from 'librechat-data-provider';
import { render, screen, waitFor, fireEvent } from '@testing-library/react';
import { ToolAuthWarningContext } from '../auth';
import ToolCall from '../ToolCall';
import { logger } from '~/utils';
// Mock dependencies
jest.mock('~/hooks', () => ({
@ -105,8 +106,21 @@ jest.mock('~/utils', () => ({
cn: (...classes: any[]) => classes.filter(Boolean).join(' '),
getToolDisplayLabel: (name: string, localize: (key: string) => string) =>
name === 'set_memory' ? localize('com_ui_tool_name_set_memory') : name,
openInNewTab: jest.requireActual('~/utils/links').openInNewTab,
}));
jest.mock('librechat-data-provider', () => {
const actual = jest.requireActual('librechat-data-provider');
return {
...actual,
dataService: {
...actual.dataService,
bindMCPOAuth: jest.fn(),
bindActionOAuth: jest.fn(),
},
};
});
describe('ToolCall', () => {
const mockProps = {
args: '{"test": "input"}',
@ -335,8 +349,10 @@ describe('ToolCall', () => {
describe('authentication flow', () => {
it('should show sign-in button when auth URL is provided', () => {
const originalOpen = window.open;
window.open = jest.fn();
const open = jest.spyOn(window, 'open').mockImplementation(() => null);
const click = jest
.spyOn(HTMLAnchorElement.prototype, 'click')
.mockImplementation(() => undefined);
renderWithRecoil(
<ToolCall
@ -351,13 +367,122 @@ describe('ToolCall', () => {
expect(signInButton).toBeInTheDocument();
fireEvent.click(signInButton);
expect(window.open).toHaveBeenCalledWith(
'https://auth.example.com',
'_blank',
'noopener,noreferrer',
);
expect(click).toHaveBeenCalledTimes(1);
const link = click.mock.instances[0] as unknown as HTMLAnchorElement;
expect(link.href).toBe('https://auth.example.com/');
expect(link.target).toBe('_blank');
expect(link.rel).toBe('noopener noreferrer');
/** A features string makes WebKit request a popup window, which iOS web apps cannot open. */
expect(open).not.toHaveBeenCalled();
window.open = originalOpen;
click.mockRestore();
open.mockRestore();
});
describe('MCP sign-in', () => {
const callbackUrl = 'https://chat.example.com/api/mcp/clickhouse/oauth/callback';
const mcpAuth = `https://mcp.example.com/authorize?redirect_uri=${encodeURIComponent(callbackUrl)}`;
const mcpProps = {
...mockProps,
name: `oauth${Constants.mcp_delimiter}clickhouse`,
auth: mcpAuth,
initialProgress: 0.5,
isSubmitting: true,
};
let click: jest.SpyInstance;
beforeEach(() => {
click = jest
.spyOn(HTMLAnchorElement.prototype, 'click')
.mockImplementation(() => undefined);
});
afterEach(() => {
click.mockRestore();
});
const signInButton = () => screen.getByRole('button', { name: 'Sign in to mcp.example.com' });
it('binds when the prompt appears and opens the provider within the tap', async () => {
(dataService.bindMCPOAuth as jest.Mock).mockResolvedValue({ success: true });
renderWithRecoil(<ToolCall {...mcpProps} />);
expect(dataService.bindMCPOAuth).toHaveBeenCalledWith('clickhouse');
await waitFor(() => expect(signInButton()).toBeEnabled());
fireEvent.click(signInButton());
expect(click).toHaveBeenCalledTimes(1);
expect((click.mock.instances[0] as unknown as HTMLAnchorElement).href).toBe(mcpAuth);
expect(dataService.bindMCPOAuth).toHaveBeenCalledTimes(2);
expect(dataService.bindMCPOAuth).toHaveBeenLastCalledWith('clickhouse');
});
it('claims the shared CSRF binding for the prompt the user taps', async () => {
(dataService.bindMCPOAuth as jest.Mock).mockResolvedValue({ success: true });
const notionCallback = 'https://chat.example.com/api/mcp/notion/oauth/callback';
const notionAuth = `https://notion.example.com/authorize?redirect_uri=${encodeURIComponent(notionCallback)}`;
const notionButton = () =>
screen.getByRole('button', { name: 'Sign in to notion.example.com' });
renderWithRecoil(
<>
<ToolCall {...mcpProps} />
<ToolCall
{...mcpProps}
name={`oauth${Constants.mcp_delimiter}notion`}
auth={notionAuth}
/>
</>,
);
await waitFor(() => expect(signInButton()).toBeEnabled());
await waitFor(() => expect(notionButton()).toBeEnabled());
expect(dataService.bindMCPOAuth).toHaveBeenLastCalledWith('notion');
fireEvent.click(signInButton());
expect(click).toHaveBeenCalledTimes(1);
expect((click.mock.instances[0] as unknown as HTMLAnchorElement).href).toBe(mcpAuth);
expect(dataService.bindMCPOAuth).toHaveBeenLastCalledWith('clickhouse');
});
it('keeps sign-in disabled until the bind lands', async () => {
let finishBind: (() => void) | undefined;
(dataService.bindMCPOAuth as jest.Mock).mockReturnValue(
new Promise((resolve) => {
finishBind = () => resolve({ success: true });
}),
);
renderWithRecoil(<ToolCall {...mcpProps} />);
expect(signInButton()).toBeDisabled();
expect(signInButton()).toHaveAttribute('aria-busy', 'true');
fireEvent.click(signInButton());
expect(click).not.toHaveBeenCalled();
finishBind!();
await waitFor(() => expect(signInButton()).toBeEnabled());
fireEvent.click(signInButton());
expect(click).toHaveBeenCalledTimes(1);
});
it('retries a failed bind on tap instead of opening the provider', async () => {
(dataService.bindMCPOAuth as jest.Mock)
.mockRejectedValueOnce(new Error('bind failed'))
.mockResolvedValue({ success: true });
renderWithRecoil(<ToolCall {...mcpProps} />);
await waitFor(() => expect(logger.error).toHaveBeenCalled());
await waitFor(() => expect(signInButton()).toBeEnabled());
fireEvent.click(signInButton());
expect(click).not.toHaveBeenCalled();
expect(screen.getByRole('alert')).toHaveTextContent('com_ui_oauth_error_generic');
await waitFor(() => expect(screen.queryByRole('alert')).not.toBeInTheDocument());
expect(dataService.bindMCPOAuth).toHaveBeenCalledTimes(2);
await waitFor(() => expect(signInButton()).toBeEnabled());
fireEvent.click(signInButton());
expect(click).toHaveBeenCalledTimes(1);
});
});
it('should not show auth section when cancelled', () => {

View file

@ -11,7 +11,7 @@ import {
} from '@librechat/client';
import CopyButton from '~/components/Messages/Content/CopyButton';
import { useLocalize, useCopyToClipboard } from '~/hooks';
import { cn } from '~/utils';
import { cn, openInNewTab } from '~/utils';
interface McpOAuthDialogProps {
open: boolean;
@ -143,7 +143,7 @@ export default function McpOAuthDialog({
type="button"
variant="submit"
className="flex-1"
onClick={() => window.open(oauthUrl, '_blank', 'noopener,noreferrer')}
onClick={() => openInNewTab(oauthUrl)}
>
{localize('com_ui_continue_oauth')}
<ExternalLink className="size-4" aria-hidden="true" />

View file

@ -3,6 +3,7 @@ import { RefreshCw, Trash2 } from 'lucide-react';
import { Button, Spinner } from '@librechat/client';
import { useLocalize, useMCPServerManager } from '~/hooks';
import { useMCPRefresh } from '~/hooks/MCP/useMCPRefresh';
import { openInNewTab } from '~/utils';
interface ServerInitializationSectionProps {
sidePanel?: boolean;
@ -97,11 +98,7 @@ export default function ServerInitializationSection({
>
{localize('com_ui_cancel')}
</Button>
<Button
variant="submit"
onClick={() => window.open(serverOAuthUrl, '_blank', 'noopener,noreferrer')}
className="flex-1"
>
<Button variant="submit" onClick={() => openInNewTab(serverOAuthUrl)} className="flex-1">
{localize('com_ui_continue_oauth')}
</Button>
</div>

View file

@ -87,9 +87,19 @@ describe('McpOAuthDialog', () => {
test('Continue opens the OAuth URL in a new tab', () => {
const openSpy = jest.spyOn(window, 'open').mockImplementation(() => null);
const clickSpy = jest
.spyOn(HTMLAnchorElement.prototype, 'click')
.mockImplementation(() => undefined);
render(<McpOAuthDialog {...baseProps} />);
fireEvent.click(screen.getByText('com_ui_continue_oauth'));
expect(openSpy).toHaveBeenCalledWith(baseProps.oauthUrl, '_blank', 'noopener,noreferrer');
expect(clickSpy).toHaveBeenCalledTimes(1);
const link = clickSpy.mock.instances[0] as unknown as HTMLAnchorElement;
expect(link.href).toBe(baseProps.oauthUrl);
expect(link.target).toBe('_blank');
expect(link.rel).toBe('noopener noreferrer');
/** A features string makes WebKit request a popup window, which iOS web apps cannot open. */
expect(openSpy).not.toHaveBeenCalled();
clickSpy.mockRestore();
openSpy.mockRestore();
});

View file

@ -15,6 +15,7 @@ import {
import { ArchivedChatsModal } from '~/components/Nav/SettingsTabs/General/ArchivedChatsModal';
import { useGetStartupConfig, useGetUserBalance } from '~/data-provider';
import { useAuthContext } from '~/hooks/AuthContext';
import { openInNewTab } from '~/utils';
import { useLocalize } from '~/hooks';
import Settings from './Settings';
import store from '~/store';
@ -55,7 +56,7 @@ function HelpSubmenu({
>
{hasHelpFaq && (
<Menu.MenuItem
onClick={() => window.open(helpAndFaqURL, '_blank', 'noopener,noreferrer')}
onClick={() => openInNewTab(helpAndFaqURL)}
className="select-item text-sm"
>
<LifeBuoy className="icon-md" aria-hidden="true" />
@ -69,7 +70,7 @@ function HelpSubmenu({
{showLegalDivider && (hasTos || hasPrivacy) && <DropdownMenuSeparator />}
{hasTos && (
<Menu.MenuItem
onClick={() => window.open(termsOfServiceURL, '_blank', 'noopener,noreferrer')}
onClick={() => openInNewTab(termsOfServiceURL)}
className="select-item text-sm"
>
<Scale className="icon-md" aria-hidden="true" />
@ -78,7 +79,7 @@ function HelpSubmenu({
)}
{hasPrivacy && (
<Menu.MenuItem
onClick={() => window.open(privacyPolicyURL, '_blank', 'noopener,noreferrer')}
onClick={() => openInNewTab(privacyPolicyURL)}
className="select-item text-sm"
>
<ShieldCheck className="icon-md" aria-hidden="true" />

View file

@ -0,0 +1,151 @@
import React from 'react';
import '@testing-library/jest-dom/extend-expect';
import { render, screen, waitFor, fireEvent } from '@testing-library/react';
import type { MCPServerStatusIconProps } from '~/components/MCP/MCPServerStatusIcon';
import type { MCPServerDefinition } from '~/hooks';
import MCPServerCard from './MCPServerCard';
const mockInitializeServer = jest.fn();
const mockGetOAuthUrl = jest.fn();
jest.mock('~/hooks', () => ({
useLocalize: () => (key: string) => key,
useMCPServerManager: () => ({
initializeServer: mockInitializeServer,
revokeOAuthForServer: jest.fn(),
getOAuthUrl: mockGetOAuthUrl,
}),
}));
jest.mock('@librechat/client', () => ({
MCPIcon: () => <span />,
}));
jest.mock('./MCPCardActions', () => ({
__esModule: true,
default: ({ onInitialize }: { onInitialize: () => void }) => (
<button type="button" onClick={onInitialize}>
{'com_nav_mcp_connect'}
</button>
),
}));
jest.mock('./MCPServerDialog', () => ({ __esModule: true, default: () => null }));
jest.mock('./MCPStatusBadge', () => ({ getStatusDotColor: () => '' }));
jest.mock('~/components/ui/CustomIcon', () => ({ __esModule: true, default: () => null }));
jest.mock('~/components/MCP/McpOAuthDialog', () => ({
__esModule: true,
default: ({ open, oauthUrl }: { open: boolean; oauthUrl: string }) =>
open ? <div role="dialog">{oauthUrl}</div> : null,
}));
const server = {
serverName: 'clickhouse',
config: {},
effectivePermissions: 0,
} as unknown as MCPServerDefinition;
/** Mirrors the manager's shared state: the flow URL exists only while initializing. */
const renderCard = (isInitializing: boolean, sharedOAuthUrl: string | null = null) => {
mockGetOAuthUrl.mockReturnValue(sharedOAuthUrl);
const statusProps = {
serverName: 'clickhouse',
serverStatus: { connectionState: 'disconnected', requiresOAuth: true },
onConfigClick: jest.fn(),
isInitializing,
canCancel: true,
onCancel: jest.fn(),
hasCustomUserVars: false,
} as unknown as MCPServerStatusIconProps;
return (
<MCPServerCard
server={server}
getServerStatusIconProps={() => statusProps}
canCreateEditMCPs={false}
/>
);
};
const firstUrl = 'https://auth.example/authorize?flow=1';
describe('MCPServerCard', () => {
afterEach(() => {
jest.clearAllMocks();
});
test('surfaces the authorization URL in the OAuth dialog instead of opening a tab', async () => {
const open = jest.spyOn(window, 'open').mockImplementation(() => null);
mockInitializeServer.mockResolvedValue({
success: true,
oauthRequired: true,
oauthUrl: firstUrl,
});
const { rerender } = render(renderCard(false));
fireEvent.click(screen.getByText('com_nav_mcp_connect'));
await waitFor(() => expect(mockInitializeServer).toHaveBeenCalledWith('clickhouse', false));
rerender(renderCard(true, firstUrl));
expect(await screen.findByRole('dialog')).toHaveTextContent(firstUrl);
expect(open).not.toHaveBeenCalled();
rerender(renderCard(false));
expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
open.mockRestore();
});
test('keeps the OAuth dialog closed when connecting needs no authorization', async () => {
mockInitializeServer.mockResolvedValue({ success: true, oauthRequired: false });
const { rerender } = render(renderCard(false));
fireEvent.click(screen.getByText('com_nav_mcp_connect'));
await waitFor(() => expect(mockInitializeServer).toHaveBeenCalled());
rerender(renderCard(true));
expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
});
test('stays closed for flows it did not start once its own flow ended', async () => {
mockInitializeServer.mockResolvedValueOnce({
success: true,
oauthRequired: true,
oauthUrl: firstUrl,
});
const { rerender } = render(renderCard(false));
fireEvent.click(screen.getByText('com_nav_mcp_connect'));
rerender(renderCard(true, firstUrl));
expect(await screen.findByRole('dialog')).toBeInTheDocument();
rerender(renderCard(false));
/** Another surface, such as the chat's MCP menu, initializes the same server. */
rerender(renderCard(true, 'https://auth.example/authorize?flow=2'));
expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
});
test('does not reopen a previous flow while the next connect is pending', async () => {
mockInitializeServer.mockResolvedValueOnce({
success: true,
oauthRequired: true,
oauthUrl: firstUrl,
});
const { rerender } = render(renderCard(false));
fireEvent.click(screen.getByText('com_nav_mcp_connect'));
rerender(renderCard(true, firstUrl));
expect(await screen.findByRole('dialog')).toBeInTheDocument();
rerender(renderCard(false));
let finishSecond: ((value: { success: boolean; oauthRequired: boolean }) => void) | undefined;
mockInitializeServer.mockReturnValueOnce(
new Promise((resolve) => {
finishSecond = resolve;
}),
);
fireEvent.click(screen.getByText('com_nav_mcp_connect'));
rerender(renderCard(true));
expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
finishSecond!({ success: true, oauthRequired: false });
await waitFor(() => expect(mockInitializeServer).toHaveBeenCalledTimes(2));
expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
});
});

View file

@ -1,8 +1,9 @@
import { useState, useRef } from 'react';
import { useState, useRef, useEffect } from 'react';
import { MCPIcon } from '@librechat/client';
import { PermissionBits, hasPermissions } from 'librechat-data-provider';
import type { MCPServerStatusIconProps } from '~/components/MCP/MCPServerStatusIcon';
import type { MCPServerDefinition } from '~/hooks';
import McpOAuthDialog from '~/components/MCP/McpOAuthDialog';
import { useMCPServerManager, useLocalize } from '~/hooks';
import { getStatusDotColor } from './MCPStatusBadge';
import CustomIcon from '~/components/ui/CustomIcon';
@ -31,8 +32,9 @@ export default function MCPServerCard({
}: MCPServerCardProps) {
const localize = useLocalize();
const triggerRef = useRef<HTMLDivElement>(null);
const { initializeServer, revokeOAuthForServer } = useMCPServerManager();
const { initializeServer, revokeOAuthForServer, getOAuthUrl } = useMCPServerManager();
const [dialogOpen, setDialogOpen] = useState(false);
const [awaitingOAuth, setAwaitingOAuth] = useState(false);
const statusIconProps = getServerStatusIconProps(server.serverName);
const {
@ -49,8 +51,20 @@ export default function MCPServerCard({
const description = server.config?.description;
const statusDotColor = getStatusDotColor(serverStatus, isInitializing);
const canEdit = canCreateEditMCPs && canEditThisServer;
/** The shared flow URL is cleared when its initialization ends, so it can never be stale. */
const sharedOAuthUrl = getOAuthUrl(server.serverName);
const handleInitialize = () => {
useEffect(() => {
if (!isInitializing) {
setAwaitingOAuth(false);
}
}, [isInitializing]);
/**
* `autoOpenOAuth=false` surfaces the authorization URL in the OAuth dialog, whose Continue opens
* it inside the tap. A tab opened after the initialize request is blocked on iOS home-screen apps.
*/
const handleInitialize = async () => {
/** If server has custom user vars and is not already connected, show config dialog first
* This ensures users can enter credentials before initialization attempts
*/
@ -58,7 +72,11 @@ export default function MCPServerCard({
onConfigClick({ stopPropagation: () => {}, preventDefault: () => {} } as React.MouseEvent);
return;
}
initializeServer(server.serverName);
setAwaitingOAuth(false);
const response = await initializeServer(server.serverName, false);
if (response?.oauthRequired && response.oauthUrl) {
setAwaitingOAuth(true);
}
};
const handleRevoke = () => {
@ -156,6 +174,17 @@ export default function MCPServerCard({
server={server}
/>
)}
<McpOAuthDialog
open={awaitingOAuth && isInitializing && sharedOAuthUrl != null}
onOpenChange={(open) => {
if (!open) {
setAwaitingOAuth(false);
}
}}
serverName={server.serverName}
oauthUrl={sharedOAuthUrl ?? ''}
iconUrl={server.config?.iconPath}
/>
</>
);
}

View file

@ -45,6 +45,7 @@ import {
import { useGetStartupConfig, useMCPServersQuery, useMCPToolsQuery } from '~/data-provider';
import { mcpServerInitStatesAtom, getServerInitState } from '~/store/mcp';
import { getMCPReinitializeErrorMessage } from './errors';
import { openInNewTab } from '~/utils';
export interface MCPServerDefinition {
serverName: string;
@ -514,7 +515,7 @@ export function useMCPServerManager({
});
if (autoOpenOAuth) {
window.open(response.oauthUrl, '_blank', 'noopener,noreferrer');
openInNewTab(response.oauthUrl);
}
startServerPolling(serverName, response.flowId, response.oauthTimeout);

View file

@ -31,6 +31,7 @@ export * from './messages';
export * from './focus';
export * from './tokens';
export * from './redirect';
export * from './links';
export * from './languages';
export * from './conversation';
export * from './endpoints';

15
client/src/utils/links.ts Normal file
View file

@ -0,0 +1,15 @@
/**
* Opens `url` in a new tab the way a `target="_blank"` link does, without giving the new page an
* opener or a referrer. Call it synchronously inside the user's click: `window.open` with a
* `noopener,noreferrer` features string asks WebKit for a popup window, which Safari opens as a
* separate window and an iOS home-screen web app does not open at all.
*/
export function openInNewTab(url: string): void {
const link = document.createElement('a');
link.href = url;
link.target = '_blank';
link.rel = 'noopener noreferrer';
document.body.appendChild(link);
link.click();
link.remove();
}