fix(desktop-browser): label frame dialogs with their own origin and cover reload leave prompts

Author: waleedlatif1

apps/desktop/e2e/browser-page-dialogs.spec.ts

@@ -186,10 +186,8 @@ test('page dialogs wait for the user on their page and stay automatic for the ag
             .getAllWebContents()
             .find((candidate) => candidate.getURL().startsWith(url))
           if (!contents) throw new Error('No page')
-          const rect = JSON.parse(
-            await contents.executeJavaScript(
-              `JSON.stringify(document.querySelector(${JSON.stringify(selector)}).getBoundingClientRect())`
-            )
+          const rect: { x: number; y: number } = await contents.executeJavaScript(
+            `(() => { const { x, y } = document.querySelector(${JSON.stringify(selector)}).getBoundingClientRect(); return { x, y } })()`
           )
           const point = { x: Math.round(rect.x + 5), y: Math.round(rect.y + 5) }
           contents.sendInputEvent({ type: 'mouseDown', ...point, button: 'left', clickCount: 1 })
@@ -253,6 +251,15 @@ test('page dialogs wait for the user on their page and stay automatic for the ag
       expect(await inPage<string>("document.getElementById('draft').value")).toBe('draft')
     })
 
+    await check('Reload of a draft asks too, and Stay keeps it', async () => {
+      await panelAction({ action: 'reload' })
+      await expect.poll(pageDialog).toMatchObject({ kind: 'beforeunload' })
+      const dialog = await pageDialog()
+      await panelAction({ action: 'respond-dialog', requestId: dialog?.requestId, allowed: false })
+      await expect.poll(pageDialog).toBeNull()
+      expect(await inPage<string>("document.getElementById('draft').value")).toBe('draft')
+    })
+
     await check('Leave lets the navigation through without asking again', async () => {
       await panelAction({ action: 'navigate', url: `${site}/next` })
       await expect.poll(pageDialog).toMatchObject({ kind: 'beforeunload' })

apps/desktop/src/main/browser-agent/cdp.ts

@@ -47,6 +47,7 @@ export interface CdpCallbacks {
   offerToUser: (
     kind: 'alert' | 'confirm',
     message: string,
+    frameUrl: string,
     respond: (accept: boolean) => void
   ) => boolean
   /** The page closed its dialog itself, by navigating away or crashing. */
@@ -214,7 +215,8 @@ function handleDebuggerEvent(
     // action asked for a specific answer. Electron decides beforeunload itself
     // (will-prevent-unload), so that kind is only acknowledged here.
     if (!requested && (type === 'alert' || type === 'confirm')) {
-      const offered = callbacks?.offerToUser(type, message, (accept) => {
+      const frameUrl = typeof params.url === 'string' ? params.url : ''
+      const offered = callbacks?.offerToUser(type, message, frameUrl, (accept) => {
         void answerDialog(contents, { accept }, parentSessionId).then((handled) => {
           if (!handled) logger.warn('Could not answer page dialog for the user', { type })
         })

apps/desktop/src/main/browser-agent/driver.ts

@@ -617,9 +617,9 @@ function instrumentTab(contents: WebContents): void {
         const requested = driverScopeState().dialogResponse
         return requested?.contents === contents ? requested.response : null
       }),
-    offerToUser: (kind, message, respond) =>
+    offerToUser: (kind, message, frameUrl, respond) =>
       session.withBrowserScope(scopeId, () =>
-        session.offerPageDialogToUser(contents, kind, message, respond)
+        session.offerPageDialogToUser(contents, { kind, message, frameUrl }, respond)
       ),
     onDialogClosed: inScope(() => session.notePageDialogClosed(contents)),
     claimUserLeave: () => session.withBrowserScope(scopeId, () => session.claimUserLeave(contents)),

apps/desktop/src/main/browser-agent/session.ts

@@ -1901,16 +1901,23 @@ function userOwnsPageDialogs(tab: AgentTab): boolean {
   return automationTabClaimedByUser() && !currentScope.automationActive
 }
 
+/**
+ * Holds a dialog for the user. `frameUrl` is the frame that opened it, so an
+ * embedded site's dialog is labelled with its own origin, not the page's.
+ */
 function holdPageDialogForUser(
   tab: AgentTab,
-  kind: BrowserPageDialog['kind'],
-  message: string,
+  {
+    kind,
+    message,
+    frameUrl,
+  }: { kind: BrowserPageDialog['kind']; message: string; frameUrl: string },
   respond: (accept: boolean) => void
 ): void {
   if (tab.pageDialog) answerPageDialog(tab, false)
   let origin = ''
   try {
-    origin = new URL(tab.view.webContents.getURL()).origin
+    origin = new URL(frameUrl || tab.view.webContents.getURL()).origin
   } catch {}
   tab.pageDialog = { request: { requestId: generateId(), kind, message, origin }, respond }
   events?.onPageStateChanged(tab.view.webContents)
@@ -1931,13 +1938,12 @@ function answerPageDialog(tab: AgentTab, accept: boolean): void {
  */
 export function offerPageDialogToUser(
   contents: WebContents,
-  kind: 'alert' | 'confirm',
-  message: string,
+  dialog: { kind: 'alert' | 'confirm'; message: string; frameUrl: string },
   respond: (accept: boolean) => void
 ): boolean {
   const tab = tabForContents(contents)
   if (!tab || !userOwnsPageDialogs(tab)) return false
-  holdPageDialogForUser(tab, kind, message, respond)
+  holdPageDialogForUser(tab, dialog, respond)
   return true
 }
 
@@ -1955,6 +1961,7 @@ export function respondToPageDialog(requestId: string, accept: boolean): void {
   if (tab) answerPageDialog(tab, accept)
 }
 
+/** The dialog on this page awaiting the user's answer, if any. */
 export function pageDialogForContents(contents: WebContents): BrowserPageDialog | undefined {
   return tabForContents(contents)?.pageDialog?.request
 }
@@ -1970,7 +1977,7 @@ export function claimUserLeave(contents: WebContents): boolean {
   const leave = tab.pendingLeave
   tab.pendingLeave = undefined
   if (!leave || !userOwnsPageDialogs(tab)) return false
-  holdPageDialogForUser(tab, 'beforeunload', '', (accept) => {
+  holdPageDialogForUser(tab, { kind: 'beforeunload', message: '', frameUrl: '' }, (accept) => {
     if (!accept) return
     tab.allowNextUnload = true
     leave()