fix(mcp): harden popup-first reopen edges

- Retire prior flows as soon as the named popup opens (the open already blanked
  any prior auth window; a failed start must not leave a windowless flow
  'connecting' for the 10-minute safety timeout).
- Check the COOP-fallback window.open result; when blocked, clear the state and
  toast instead of registering a windowless pending flow.
- Feature-detect AbortSignal.timeout (Safari <16) with an AbortController
  fallback for the bounded /oauth/start.

Author: waleedlatif1

apps/sim/hooks/mcp/use-mcp-oauth-popup.test.tsx

@@ -180,7 +180,7 @@ describe('useMcpOauthPopup', () => {
     hook.unmount()
   })
 
-  it('keeps the row connecting when a reopen fails but a prior flow is still live', async () => {
+  it('clears the row when a reopen fails (the reopen blanked the prior window)', async () => {
     mockStartOauth.mockResolvedValueOnce({
       status: 'redirect',
       authorizationUrl: 'https://as.example/a?state=st-a',
@@ -195,14 +195,15 @@ describe('useMcpOauthPopup', () => {
     await flush()
     expect(hook.result().connectingServers.has('s1')).toBe(true)
 
-    // Reopen fails (e.g. popup blocked). The still-live prior flow must keep the row connecting
-    // rather than the failed attempt clearing it (deterministic reference counting).
-    mockStartOauth.mockRejectedValueOnce(new Error('Popup blocked'))
+    // Reopen fails after the named-window open already navigated the prior auth window to
+    // about:blank — the prior flow is moot (windowless), so BOTH it and the failed attempt
+    // clear, leaving the row idle with 'Connect with OAuth' immediately available.
+    mockStartOauth.mockRejectedValueOnce(new Error('start failed'))
     await act(async () => {
       await hook.result().startOauthForServer('s1')
     })
     await flush()
-    expect(hook.result().connectingServers.has('s1')).toBe(true)
+    expect(hook.result().connectingServers.has('s1')).toBe(false)
 
     hook.unmount()
   })

apps/sim/hooks/mcp/use-mcp-oauth-popup.ts

@@ -168,14 +168,14 @@ export function useMcpOauthPopup({ workspaceId }: UseMcpOauthPopupProps) {
         return
       }
       popup.focus?.()
+      // Opening the shared named window just navigated ANY prior authorization window to
+      // about:blank, so prior flows for this server are moot regardless of how this attempt
+      // ends — retire them now (a failed start must not leave a windowless flow "connecting"
+      // for the 10-minute safety timeout).
+      retireFlows(serverId)
       incConnecting(serverId) // this attempt begins
       try {
         const result = await startOauth({ serverId, workspaceId })
-        // The replacement start succeeded (already-authorized, or a fresh authorization is
-        // underway), so retire any prior attempt for this server now — its result is moot and
-        // the server-side `state` it depended on has been overwritten. A *failed* start
-        // (below) leaves prior flows intact.
-        retireFlows(serverId)
         if (result.status === 'already_authorized') {
           try {
             popup.close()
@@ -185,11 +185,18 @@ export function useMcpOauthPopup({ workspaceId }: UseMcpOauthPopupProps) {
           return
         }
         const { authorizationUrl, state } = result
+        let navigated = true
         try {
           popup.location.replace(authorizationUrl)
         } catch {
           // A COOP-severed reused window can refuse scripted navigation; reopen by name.
-          window.open(authorizationUrl, `mcp-oauth-${serverId}`)
+          // This runs after the await, so it can itself be popup-blocked — check it.
+          navigated = window.open(authorizationUrl, `mcp-oauth-${serverId}`) !== null
+        }
+        if (!navigated) {
+          decConnecting(serverId)
+          toast.error('Popup blocked. Please allow popups for this site and retry.')
+          return
         }
         // Track the in-flight flow by its `state` nonce for the BroadcastChannel gate, bounded by
         // a safety timeout in case no result ever arrives (popup abandoned, or a callback the

apps/sim/hooks/queries/mcp.ts

@@ -317,12 +317,28 @@ export function useStartMcpOauth() {
   return useMutation<StartMcpOauthMutationResult, Error, { serverId: string; workspaceId: string }>(
     {
       mutationFn: async ({ serverId, workspaceId }) => {
-        const result = await requestJson(startMcpOauthContract, {
-          query: { serverId, workspaceId },
-          // A stalled /oauth/start must settle so the caller can reset the connecting
-          // state and close its pre-opened popup instead of appearing bricked.
-          signal: AbortSignal.timeout(30_000),
-        })
+        // A stalled /oauth/start must settle so the caller can reset the connecting
+        // state and close its pre-opened popup instead of appearing bricked.
+        // Feature-detect AbortSignal.timeout (Safari <16 lacks it) with a plain
+        // controller fallback.
+        let timeoutSignal: AbortSignal | undefined
+        let timeoutId: ReturnType<typeof setTimeout> | undefined
+        if (typeof AbortSignal.timeout === 'function') {
+          timeoutSignal = AbortSignal.timeout(30_000)
+        } else {
+          const controller = new AbortController()
+          timeoutId = setTimeout(() => controller.abort(new Error('Request timed out')), 30_000)
+          timeoutSignal = controller.signal
+        }
+        let result: Awaited<ReturnType<typeof requestJson<typeof startMcpOauthContract>>>
+        try {
+          result = await requestJson(startMcpOauthContract, {
+            query: { serverId, workspaceId },
+            signal: timeoutSignal,
+          })
+        } finally {
+          if (timeoutId !== undefined) clearTimeout(timeoutId)
+        }
         if (result.status === 'already_authorized') return { status: 'already_authorized' }
 
         const parsedUrl = new URL(result.authorizationUrl)