fix(desktop): keep sign-in handoffs current across cancel, migration, and sign-out

Retire in-flight launches on cancel, newer continue, and account teardown;
move a provisional chat's handoff with its browser scope; skip reopening the
tab when a bring-back's handoff was superseded; pin the platform in the
continue-sign-in tests so they pass on Linux CI.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: waleedlatif1

apps/desktop/src/main/browser-import/index.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 import { BROWSER_SOURCES, type BrowserSource } from '@/main/browser-import/browser-sources'
 import type { BrowserProfile } from '@/main/browser-import/types'
 import { emptySkipCounts } from '@/main/browser-import/types'
@@ -35,9 +35,33 @@ vi.mock('@/main/browser-import/chromium-crypto', async (importOriginal) => ({
 const { openInBrowserProfile } = await import('@/main/browser-import/browser-launch')
 const { listAllBrowserProfiles } = await import('@/main/browser-import/chromium-profiles')
 const { readBrowserCookies } = await import('@/main/browser-import/chromium-cookies')
-const { bringSignInBack, cancelSignIn, continueSignIn, getPendingSignIn } = await import(
-  '@/main/browser-import'
-)
+const {
+  bringSignInBack,
+  cancelSignIn,
+  clearSignIns,
+  continueSignIn,
+  getPendingSignIn,
+  migrateSignIn,
+} = await import('@/main/browser-import')
+
+/** The importer is macOS-only; pin the platform so the suite means the same on every runner. */
+const realPlatform = Object.getOwnPropertyDescriptor(process, 'platform')
+beforeAll(() => Object.defineProperty(process, 'platform', { value: 'darwin' }))
+afterAll(() => {
+  if (realPlatform) Object.defineProperty(process, 'platform', realPlatform)
+})
+
+/** Holds the next browser launch open until the test releases it. */
+function holdLaunch(): () => void {
+  let release: (() => void) | undefined
+  vi.mocked(openInBrowserProfile).mockImplementationOnce(
+    () =>
+      new Promise<void>((resolve) => {
+        release = resolve
+      })
+  )
+  return () => release?.()
+}
 
 const ARC = BROWSER_SOURCES.find(({ id }) => id === 'arc') as BrowserSource
 const PROFILE: BrowserProfile = {
@@ -71,12 +95,10 @@ function readsCookies(count: number) {
 }
 
 beforeEach(() => {
-  vi.clearAllMocks()
   vi.mocked(listAllBrowserProfiles).mockResolvedValue([PROFILE])
   vi.mocked(openInBrowserProfile).mockResolvedValue()
   readsCookies(2)
-  cancelSignIn('chat-a')
-  cancelSignIn('chat-b')
+  clearSignIns()
 })
 
 describe('continueSignIn', () => {
@@ -132,6 +154,7 @@ describe('bringSignInBack', () => {
     await expect(bringSignInBack('chat-a')).resolves.toEqual({
       result: { cookiesImported: 2, cookiesSkipped: 0 },
       handoff: expect.objectContaining({ tabId: 'tab-1', url: SIGN_IN_URL }),
+      current: true,
     })
     expect(readBrowserCookies).toHaveBeenCalledWith('/arc/Profile 2/Cookies', expect.any(Buffer), {
       scope: { domain: 'amazon.com', exact: false },
@@ -167,7 +190,10 @@ describe('bringSignInBack', () => {
     await vi.waitFor(() => expect(finishRead).toBeTypeOf('function'))
     await continueSignIn('chat-a', request('https://accounts.google.com/signin'))
     finishRead?.()
-    await expect(broughtBack).resolves.toMatchObject({ result: { cookiesImported: 2 } })
+    await expect(broughtBack).resolves.toMatchObject({
+      result: { cookiesImported: 2 },
+      current: false,
+    })
 
     expect(getPendingSignIn('chat-a')).toEqual({ site: 'google.com', browserLabel: 'Arc' })
   })
@@ -189,3 +215,56 @@ describe('bringSignInBack', () => {
     expect(readBrowserCookies).not.toHaveBeenCalled()
   })
 })
+
+describe('a handoff retired or moved while its browser launches', () => {
+  it('records nothing once a cancel lands mid-launch', async () => {
+    const release = holdLaunch()
+    const continuing = continueSignIn('chat-a', request())
+    await vi.waitFor(() => expect(openInBrowserProfile).toHaveBeenCalled())
+    cancelSignIn('chat-a')
+    release()
+
+    await expect(continuing).resolves.toEqual({})
+    expect(getPendingSignIn('chat-a')).toBeNull()
+  })
+
+  it('lets a newer continue win over an older launch that finishes later', async () => {
+    const release = holdLaunch()
+    const older = continueSignIn('chat-a', request())
+    await vi.waitFor(() => expect(openInBrowserProfile).toHaveBeenCalled())
+    await continueSignIn('chat-a', request('https://accounts.google.com/signin'))
+    release()
+
+    await expect(older).resolves.toEqual({})
+    expect(getPendingSignIn('chat-a')).toEqual({ site: 'google.com', browserLabel: 'Arc' })
+  })
+
+  it('follows a provisional chat to its saved id, mid-launch or after', async () => {
+    const release = holdLaunch()
+    const continuing = continueSignIn('pending:new-chat', request())
+    await vi.waitFor(() => expect(openInBrowserProfile).toHaveBeenCalled())
+    migrateSignIn('pending:new-chat', 'chat-a')
+    release()
+    await continuing
+
+    expect(getPendingSignIn('chat-a')).toEqual({ site: 'amazon.com', browserLabel: 'Arc' })
+    expect(getPendingSignIn('pending:new-chat')).toBeNull()
+    migrateSignIn('chat-a', 'chat-b')
+    await expect(bringSignInBack('chat-b')).resolves.toMatchObject({
+      result: { cookiesImported: 2 },
+    })
+  })
+
+  it('forgets every handoff on account teardown, including one still launching', async () => {
+    await continueSignIn('chat-a', request())
+    const release = holdLaunch()
+    const continuing = continueSignIn('chat-b', request())
+    await vi.waitFor(() => expect(openInBrowserProfile).toHaveBeenCalledTimes(2))
+    clearSignIns()
+    release()
+
+    await expect(continuing).resolves.toEqual({})
+    expect(getPendingSignIn('chat-a')).toBeNull()
+    expect(getPendingSignIn('chat-b')).toBeNull()
+  })
+})

apps/desktop/src/main/browser-import/index.ts

@@ -89,66 +89,110 @@ interface SignInHandoff {
   scope: SiteScope
 }
 
-/** At most one per chat: continuing another page replaces the previous handoff. */
-const handoffsByScope = new Map<string, SignInHandoff>()
+/**
+ * A chat's handoff, created before the browser launches so a cancel, a newer
+ * continue, sign-out, or the chat's id migrating during the launch can retire
+ * or move it. A launch records its handoff only while its slot is still current.
+ */
+interface HandoffSlot {
+  handoff?: SignInHandoff
+}
+
+/** At most one per chat: continuing another page replaces the previous slot. */
+const slotsByScope = new Map<string, HandoffSlot>()
 
 function pendingSignIn({ profile, scope }: SignInHandoff): BrowserPendingSignIn {
   return { site: scope.domain, browserLabel: profile.source.label }
 }
 
+function isCurrentSlot(slot: HandoffSlot): boolean {
+  for (const current of slotsByScope.values()) if (current === slot) return true
+  return false
+}
+
 /**
  * Opens a built-in browser page in one of the user's own browser profiles and
  * remembers it for the chat, so {@link bringSignInBack} imports the site the
  * user left from and reopens that page, whatever the tab shows by then.
  *
  * Only an https page goes, and only to a profile the importer can read back
- * from: a sign-in that can never return would strand the user.
+ * from: a sign-in that can never return would strand the user. A handoff
+ * retired while its browser launched resolves with neither `pending` nor
+ * `error`.
  */
 export async function continueSignIn(
   scopeId: string,
   request: { profileId: string; tabId: string; url: string }
 ): Promise<BrowserContinueSignInResult> {
   const scope = isSafeExternalUrl(request.url) ? siteScopeFor(new URL(request.url).hostname) : null
   if (!scope) return { error: 'unsupported-page' }
+  const slot: HandoffSlot = {}
+  slotsByScope.set(scopeId, slot)
   const profiles = await listAllBrowserProfiles().catch(() => [])
   const profile = profiles.find(({ id }) => id === request.profileId)
-  if (!profile?.cookiesPath) return { error: 'chrome-not-found' }
+  if (!profile?.cookiesPath) return retire(slot, { error: 'chrome-not-found' })
   try {
     await openInBrowserProfile(profile.source.bundleId, profile.directory, request.url)
   } catch {
-    return { error: 'launch-failed' }
+    return retire(slot, { error: 'launch-failed' })
+  }
+  if (!isCurrentSlot(slot)) return {}
+  slot.handoff = { profile, tabId: request.tabId, url: request.url, scope }
+  return { pending: pendingSignIn(slot.handoff) }
+}
+
+function retire(
+  slot: HandoffSlot,
+  result: BrowserContinueSignInResult
+): BrowserContinueSignInResult {
+  for (const [scopeId, current] of slotsByScope) {
+    if (current === slot) slotsByScope.delete(scopeId)
   }
-  const handoff = { profile, tabId: request.tabId, url: request.url, scope }
-  handoffsByScope.set(scopeId, handoff)
-  return { pending: pendingSignIn(handoff) }
+  return result
 }
 
 export function getPendingSignIn(scopeId: string): BrowserPendingSignIn | null {
-  const handoff = handoffsByScope.get(scopeId)
+  const handoff = slotsByScope.get(scopeId)?.handoff
   return handoff ? pendingSignIn(handoff) : null
 }
 
 export function cancelSignIn(scopeId: string): void {
-  handoffsByScope.delete(scopeId)
+  slotsByScope.delete(scopeId)
+}
+
+/** Follows a provisional chat to its saved id, including a launch still in flight. */
+export function migrateSignIn(fromScopeId: string, toScopeId: string): void {
+  const slot = slotsByScope.get(fromScopeId)
+  if (!slot) return
+  slotsByScope.delete(fromScopeId)
+  slotsByScope.set(toScopeId, slot)
+}
+
+/** Account teardown: forgets every handoff and retires launches still in flight. */
+export function clearSignIns(): void {
+  slotsByScope.clear()
 }
 
 /**
  * Imports the chat's handed-off site from the profile it was continued in. The
  * handoff stays pending until something comes back, so the user can finish
- * signing in and try again.
+ * signing in and try again. `current` is false when a cancel, a newer
+ * continue, or teardown retired the handoff while it was being imported.
  */
-export async function bringSignInBack(
-  scopeId: string
-): Promise<{ result: BrowserImportResult; handoff?: { tabId: string; url: string } }> {
-  const handoff = handoffsByScope.get(scopeId)
-  if (!handoff) return { result: cookieFailure('unknown') }
+export async function bringSignInBack(scopeId: string): Promise<{
+  result: BrowserImportResult
+  handoff?: { tabId: string; url: string }
+  current?: boolean
+}> {
+  const slot = slotsByScope.get(scopeId)
+  const handoff = slot?.handoff
+  if (!slot || !handoff) return { result: cookieFailure('unknown') }
   const result = await runCookieImport(
     handoff.profile.id,
     { ...deps(), listProfiles: async () => [handoff.profile] },
     handoff.scope
   )
-  if (result.cookiesImported > 0 && handoffsByScope.get(scopeId) === handoff) {
-    handoffsByScope.delete(scopeId)
-  }
-  return { result, handoff }
+  const current = slotsByScope.get(scopeId) === slot && slot.handoff === handoff
+  if (current && result.cookiesImported > 0) slotsByScope.delete(scopeId)
+  return { result, handoff, current }
 }

apps/desktop/src/main/index.ts

@@ -53,6 +53,7 @@ import {
   setBrowserAppearanceTheme as setAgentBrowserTheme,
   setPanelFocused as setBrowserAgentPanelFocused,
 } from '@/main/browser-agent/session'
+import { clearSignIns } from '@/main/browser-import'
 import { attachClientInfo } from '@/main/client-info'
 import { NativeComputerUseClient } from '@/main/computer-use/native-client'
 import { ComputerUseService } from '@/main/computer-use/service'
@@ -390,6 +391,7 @@ function main(): void {
       clearHandoffState: async () => {
         const stores = [
           { label: 'sign-in handoff state', clear: () => handoff.clear() },
+          { label: 'browser sign-in handoffs', clear: clearSignIns },
           { label: 'recent tasks', clear: () => tray?.clearRecentChats() },
           {
             label: 'renderer session state',
@@ -895,6 +897,7 @@ function main(): void {
         ...(kind === 'account' && origin
           ? [
               { label: 'sign-in handoff state', clear: () => handoff.clear() },
+              { label: 'browser sign-in handoffs', clear: clearSignIns },
               { label: 'background executor', clear: () => desktopExecutor.signOut() },
               {
                 label: 'terminal sessions',

apps/desktop/src/main/ipc.test.ts

@@ -26,9 +26,11 @@ vi.mock('@/main/browser-import', () => ({
   bringSignInBack: vi.fn(async () => ({
     result: { cookiesImported: 2, cookiesSkipped: 0 },
     handoff: { tabId: 'tab-1', url: 'https://signin.example.com/login' },
+    current: true,
   })),
   cancelSignIn: vi.fn(),
   getPendingSignIn: vi.fn(() => null),
+  migrateSignIn: vi.fn(),
 }))
 
 vi.mock('@/main/browser-search/suggestions', () => ({
@@ -149,6 +151,7 @@ import {
   importChromeCookies,
   importChromePasswords,
   listChromeImportProfiles,
+  migrateSignIn,
 } from '@/main/browser-import'
 import { getSearchSuggestions } from '@/main/browser-search/suggestions'
 import { ComputerUseService } from '@/main/computer-use/service'
@@ -1149,11 +1152,23 @@ describe('registerIpcHandlers', () => {
     })
 
     expect(migrate).not.toHaveBeenCalled()
+    expect(migrateSignIn).not.toHaveBeenCalled()
     expect(deps.scopeEvents.activateBrowser).toHaveBeenCalledTimes(1)
 
     migrate.mockRestore()
   })
 
+  it('moves a pending sign-in with the browser scope when a new chat gets its id', async () => {
+    const migrate = vi.spyOn(browserDriver, 'migrateBrowserScope').mockReturnValue(true)
+    const { invoke } = collectHandlers()
+
+    await invoke.get('browser-agent:activate-scope')?.(appEvent, 'pending:signin')
+    await invoke.get('browser-agent:migrate-scope')?.(appEvent, 'pending:signin', 'chat-saved')
+
+    expect(migrateSignIn).toHaveBeenCalledWith('pending:signin', 'chat-saved')
+    migrate.mockRestore()
+  })
+
   it('requires a live user gesture before importing Chrome cookies', async () => {
     const { invoke } = collectHandlers()
     const handler = invoke.get('browser-import:cookies')
@@ -1305,10 +1320,23 @@ describe('registerIpcHandlers', () => {
       focus.mockRestore()
     })
 
+    it('leaves the tabs alone when a newer continue retired the handoff mid-import', async () => {
+      vi.mocked(bringSignInBack).mockResolvedValueOnce({
+        result: { cookiesImported: 2, cookiesSkipped: 0 },
+        handoff: { tabId: 'tab-1', url: 'https://signin.example.com/login' },
+        current: false,
+      })
+
+      await bringBack(activeAppEvent, 'chat-signin')
+
+      expect(panelAction).not.toHaveBeenCalled()
+    })
+
     it('leaves the tabs alone when nothing came back', async () => {
       vi.mocked(bringSignInBack).mockResolvedValueOnce({
         result: { cookiesImported: 0, cookiesSkipped: 0 },
         handoff: { tabId: 'tab-1', url: 'https://signin.example.com/login' },
+        current: true,
       })
 
       await bringBack(activeAppEvent, 'chat-signin')

apps/desktop/src/main/ipc.ts

@@ -88,6 +88,7 @@ import {
   importChromeData,
   importChromePasswords,
   listChromeImportProfiles,
+  migrateSignIn,
 } from '@/main/browser-import'
 import { getSearchSuggestions } from '@/main/browser-search/suggestions'
 import { listSites } from '@/main/browser-sites'
@@ -1181,6 +1182,7 @@ export function registerIpcHandlers(deps: IpcDeps): void {
           return { tabs: [], activeTabId: null }
         }
         consumePendingScope(browserPendingScopesBySender, contents, from)
+        migrateSignIn(from, to)
         if (browserScopeBySender.get(contents) === from) {
           browserScopeBySender.set(contents, to)
           deps.scopeEvents.activateBrowser(contents, to)
@@ -1548,8 +1550,8 @@ export function registerIpcHandlers(deps: IpcDeps): void {
       handler: async (sender, rawScope) => {
         const scopeId = activeRendererScope(browserScopeBySender, sender as WebContents, rawScope)
         if (!scopeId) return { cookiesImported: 0, cookiesSkipped: 0, error: 'unknown' }
-        const { result, handoff } = await bringSignInBack(scopeId)
-        if (!handoff || result.cookiesImported === 0) return result
+        const { result, handoff, current } = await bringSignInBack(scopeId)
+        if (!handoff || !current || result.cookiesImported === 0) return result
         const tabOpen = withBrowserScope(scopeId, () =>
           peekTabsState().tabs.some(({ tabId }) => tabId === handoff.tabId)
         )

apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/use-continue-sign-in.ts

@@ -67,7 +67,7 @@ export function useContinueSignIn({ scopeId, pageUrl }: UseContinueSignInProps)
     async (profile: BrowserImportProfile) => {
       try {
         const result = await startHandoff(profile.id)
-        if (!result.pending) toast.error(CONTINUE_ERROR_MESSAGES[result.error ?? 'unknown'])
+        if (result.error) toast.error(CONTINUE_ERROR_MESSAGES[result.error])
       } catch {
         toast.error(CONTINUE_ERROR_MESSAGES.unknown)
       }