fix(mship): survive a remount while an attempt is still pending

The unobservable deadline lived in the watcher effect's closure, so it was
armed only by the mount that launched the popup. The transcript virtualizes:
a row scrolled away mid-connect came back with no window handle and no blur
behind it, and nothing re-armed the bound.

Derives the deadline from the attempt's own requestedAt and arms it for any
pending attempt, so a remount inherits the time remaining rather than
restarting the clock or losing it. A demonstrably live popup still owns the
flow and is left to the watcher.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.tsx

@@ -591,6 +591,48 @@ describe('CredentialDisplay link tag', () => {
     act(() => root.unmount())
   })
 
+  it('keeps the unobservable deadline across a remount', async () => {
+    // The transcript virtualizes, so a row can scroll away mid-connect and come
+    // back with no window handle and no blur behind it. The deadline is derived
+    // from the attempt's requestedAt rather than held in the effect, so the
+    // remounted row inherits the remaining time instead of waiting forever.
+    vi.useFakeTimers()
+    const popup = { focus: vi.fn(), closed: false }
+    const openSpy = vi
+      .spyOn(window, 'open')
+      .mockReturnValue(popup as unknown as ReturnType<typeof window.open>)
+    const data: CredentialItemData = {
+      type: 'link',
+      provider: 'google-email',
+      value:
+        'https://sim.test/api/auth/oauth2/authorize?providerId=google-email&callbackURL=https%3A%2F%2Fsim.test%2Fworkspace%2Fworkspace-1%2Fchat%2Fchat-1',
+    }
+    const first = renderCredentialLink(data)
+
+    await act(async () => {
+      first.container
+        .querySelector('a')
+        ?.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }))
+    })
+    popup.closed = true
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(60 * 1000)
+    })
+    act(() => first.root.unmount())
+
+    const second = renderCredentialLink(data)
+    expect(second.container.textContent).toContain('Waiting for Gmail connection')
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(10 * 60 * 1000)
+    })
+
+    expect(second.container.textContent).toContain('Not connected — connect Gmail')
+    vi.useRealTimers()
+    openSpy.mockRestore()
+    act(() => second.root.unmount())
+  })
+
   it('still announces the connection when the watcher released the popup first', async () => {
     // The watcher drops the window handle as soon as it stops being observable,
     // which routinely happens before React applies the storage-driven verdict.

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/use-oauth-chip-connection.ts

@@ -381,7 +381,6 @@ export function useOAuthChipConnection({
    */
   useEffect(() => {
     if (connectionStatus !== 'pending' || !popupRef.current) return
-    let unobservableTimer: number | undefined
     const poll = window.setInterval(() => {
       const observation = observePopup(popupRef.current)
       if (observation === 'live') return
@@ -390,26 +389,41 @@ export function useOAuthChipConnection({
       // could resolve an attempt a retry had since replaced.
       window.clearInterval(poll)
       popupRef.current = null
-      // Only `ended` is proof the flow finished with nothing published.
-      if (observation === 'ended') {
-        void settleFromCredentials()
-        return
-      }
-      // A closed handle and a disowned one are indistinguishable, so neither
-      // deciding now nor waiting forever is right. Closing a popup normally
-      // hands focus back and the focus verification settles it; this bounds the
-      // case where that never arrives — the opener was never blurred, or the
-      // flow completed somewhere this tab cannot see.
-      unobservableTimer = window.setTimeout(() => {
-        void settleFromCredentials()
-      }, OAUTH_POPUP_UNOBSERVABLE_TIMEOUT_MS)
+      // Only `ended` is proof the flow finished with nothing published. A
+      // closed-or-disowned handle is not — the deadline below bounds that.
+      if (observation === 'ended') void settleFromCredentials()
     }, OAUTH_POPUP_POLL_INTERVAL_MS)
-    return () => {
-      window.clearInterval(poll)
-      if (unobservableTimer !== undefined) window.clearTimeout(unobservableTimer)
-    }
+    return () => window.clearInterval(poll)
   }, [connectionStatus, settleFromCredentials])
 
+  /**
+   * Backstop deadline for a pending attempt whose outcome never becomes
+   * observable — a closed-or-disowned popup this tab cannot read, with no blur
+   * for the focus verification to work from.
+   *
+   * Bounds every pending attempt rather than only one this mount launched: the
+   * transcript virtualizes, so a row can remount onto an attempt restored from
+   * storage with no window handle at all. The deadline comes from the attempt's
+   * own `requestedAt`, so remounting re-arms with the time remaining instead of
+   * restarting the clock or dropping the bound entirely.
+   */
+  useEffect(() => {
+    if (connectionStatus !== 'pending') return
+    const attempt = readRowAttempt()
+    if (!attempt) return
+    const remaining = Math.max(
+      0,
+      OAUTH_POPUP_UNOBSERVABLE_TIMEOUT_MS - (Date.now() - attempt.requestedAt)
+    )
+    const deadline = window.setTimeout(() => {
+      // A popup still demonstrably running owns the flow; the watcher settles
+      // it the moment it ends, so there is nothing to bound here.
+      if (isPopupStillOpen(popupRef.current)) return
+      void settleFromCredentials()
+    }, remaining)
+    return () => window.clearTimeout(deadline)
+  }, [connectionStatus, readRowAttempt, settleFromCredentials])
+
   useEffect(() => {
     if (connected) onConnectedRef.current?.()
   }, [connected])