Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

fix(browser): let agents and users answer page alert, confirm and prompt dialogs on their page (#36268)

Kelvin Amoaba4410ef318e4d
diff --git a/skill-guides/orca-cli/references/browser.md b/skill-guides/orca-cli/references/browser.md
index cc84303d277..66ba42b4d1a 100644
--- a/skill-guides/orca-cli/references/browser.md
+++ b/skill-guides/orca-cli/references/browser.md
@@ -35,6 +35,8 @@ ORCA wait --page <browserPageId> --url <substring> --json
ORCA wait --page <browserPageId> --selector <css> --json
ORCA wait --page <browserPageId> --load networkidle --json
ORCA eval --page <browserPageId> --expression <js> --json
+ORCA dialog accept --page <browserPageId> [--text <answer>] --json
+ORCA dialog dismiss --page <browserPageId> --json
ORCA set device --page <browserPageId> --name "iPhone 15" --json
ORCA viewport --page <browserPageId> --width 390 --height 844 --scale 3 --mobile --json
ORCA tab list --json
@@ -70,4 +72,5 @@ Common recoveries:
- `browser_stale_ref`: run `ORCA snapshot --page <browserPageId> --json` and retry on the same page with fresh refs.
- `browser_element_not_interactable`: the element can't take that command, and the message says why (not a text field, disabled, read-only, not a `<select>`, not a file input). Re-snapshot and pick the right ref; for a custom dropdown, click it and then click the option.
- `browser_tab_not_found`: run `ORCA tab list --json` before switching or closing.
+- `browser_dialog_open` / `browser_dialog_opened`: the page has a JavaScript alert, confirm or prompt open, and the error quotes it. Answer it with `ORCA dialog accept` (`--text` for a prompt; without it a prompt takes its default) or `ORCA dialog dismiss` before any other command on that page; a command that opened it may already have taken effect, so check before repeating it.
- `browser_host_unavailable`: the desktop hosting the page is offline. Bring it back, or recreate the page with server placement if the work must outlive the desktop session.
diff --git a/src/cli/bundled-skill-guides.ts b/src/cli/bundled-skill-guides.ts
index ad8a7298850..2ed76b95bf5 100644
--- a/src/cli/bundled-skill-guides.ts
+++ b/src/cli/bundled-skill-guides.ts
@@ -846,6 +846,8 @@ const ORCA_CLI_BROWSER_REFERENCE_MARKDOWN = [
"ORCA wait --page <browserPageId> --selector <css> --json",
"ORCA wait --page <browserPageId> --load networkidle --json",
"ORCA eval --page <browserPageId> --expression <js> --json",
+ "ORCA dialog accept --page <browserPageId> [--text <answer>] --json",
+ "ORCA dialog dismiss --page <browserPageId> --json",
"ORCA set device --page <browserPageId> --name \"iPhone 15\" --json",
"ORCA viewport --page <browserPageId> --width 390 --height 844 --scale 3 --mobile --json",
"ORCA tab list --json",
@@ -881,6 +883,7 @@ const ORCA_CLI_BROWSER_REFERENCE_MARKDOWN = [
"- `browser_stale_ref`: run `ORCA snapshot --page <browserPageId> --json` and retry on the same page with fresh refs.",
"- `browser_element_not_interactable`: the element can't take that command, and the message says why (not a text field, disabled, read-only, not a `<select>`, not a file input). Re-snapshot and pick the right ref; for a custom dropdown, click it and then click the option.",
"- `browser_tab_not_found`: run `ORCA tab list --json` before switching or closing.",
+ "- `browser_dialog_open` / `browser_dialog_opened`: the page has a JavaScript alert, confirm or prompt open, and the error quotes it. Answer it with `ORCA dialog accept` (`--text` for a prompt; without it a prompt takes its default) or `ORCA dialog dismiss` before any other command on that page; a command that opened it may already have taken effect, so check before repeating it.",
"- `browser_host_unavailable`: the desktop hosting the page is offline. Bring it back, or recreate the page with server placement if the work must outlive the desktop session.",
"",
].join('\n')
diff --git a/src/main/browser/agent-browser-bridge-javascript-dialog.test.ts b/src/main/browser/agent-browser-bridge-javascript-dialog.test.ts
new file mode 100644
index 00000000000..63da510824e
--- /dev/null
+++ b/src/main/browser/agent-browser-bridge-javascript-dialog.test.ts
@@ -0,0 +1,148 @@
+import { EventEmitter } from 'node:events'
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+const { execFileMock, webContentsFromIdMock, existsSyncMock, readFileSyncMock, stdinWrites } =
+ vi.hoisted(() => ({
+ execFileMock: vi.fn(),
+ webContentsFromIdMock: vi.fn(),
+ existsSyncMock: vi.fn(() => false),
+ readFileSyncMock: vi.fn(() => Buffer.from('')),
+ stdinWrites: new Array<string>()
+ }))
+
+vi.mock('child_process', () => ({ execFile: execFileMock }))
+vi.mock('fs', () => ({
+ existsSync: existsSyncMock,
+ readFileSync: readFileSyncMock,
+ accessSync: vi.fn(),
+ chmodSync: vi.fn(),
+ constants: { X_OK: 1 }
+}))
+vi.mock('os', () => ({ platform: () => 'darwin', arch: () => 'arm64' }))
+vi.mock('electron', () => ({
+ app: { getPath: vi.fn(() => '/app'), getAppPath: vi.fn(() => '/project'), isPackaged: false },
+ webContents: { fromId: webContentsFromIdMock }
+}))
+const { CdpWsProxyMock } = vi.hoisted(() => {
+ const instances: unknown[] = []
+ const MockClass = vi.fn().mockImplementation(function (this: Record<string, unknown>) {
+ this.start = vi.fn(async () => 'ws://127.0.0.1:9222')
+ this.stop = vi.fn(async () => {})
+ this.getPort = vi.fn(() => 9222)
+ instances.push(this)
+ })
+ return { CdpWsProxyMock: Object.assign(MockClass, { instances }) }
+})
+vi.mock('./cdp-ws-proxy', () => ({ CdpWsProxy: CdpWsProxyMock }))
+
+import { AgentBrowserBridge } from './agent-browser-bridge'
+import { installBrowserJavaScriptDialogs } from './browser-javascript-dialogs'
+import { runInRemoteCliBrowserScope } from '../runtime/desktop-browser-bridge/remote-cli-browser-scope'
+import {
+ createFakeAgentBrowserChild,
+ createSucceedWith,
+ mockBrowserManager,
+ overrideBridgeWebContentsLookup,
+ resetAgentBrowserBridgeMocks,
+ type ExecFileCallback
+} from './agent-browser-bridge-test-harness'
+
+overrideBridgeWebContentsLookup(AgentBrowserBridge.prototype, webContentsFromIdMock)
+
+const succeedWith = createSucceedWith(execFileMock, stdinWrites)
+
+describe('agent commands while a page has a JavaScript dialog', () => {
+ let bridge: AgentBrowserBridge
+ let guest: Electron.WebContents & EventEmitter
+
+ const openDialog = (dialogType: string, messageText: string) => {
+ const callback = vi.fn()
+ guest.emit('-run-dialog', { dialogType, messageText, defaultPromptText: 'def' }, callback)
+ return callback
+ }
+
+ beforeEach(() => {
+ resetAgentBrowserBridgeMocks({
+ webContentsFromIdMock,
+ existsSyncMock,
+ readFileSyncMock,
+ stdinWrites,
+ cdpWsProxyInstances: CdpWsProxyMock.instances
+ })
+ // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the dialog owner only reads id, URL and its events.
+ guest = Object.assign(new EventEmitter(), {
+ id: 100,
+ debugger: new EventEmitter(),
+ isDestroyed: () => false,
+ getURL: () => 'https://example.com'
+ }) as unknown as Electron.WebContents & EventEmitter
+ installBrowserJavaScriptDialogs(guest, () => null)
+ bridge = new AgentBrowserBridge(mockBrowserManager())
+ bridge.setActiveTab(100)
+ })
+
+ it('fails fast with the dialog text until the agent answers it', async () => {
+ const callback = openDialog('prompt', 'Your name?')
+ succeedWith({ snapshot: 'tree' })
+
+ await expect(bridge.snapshot()).rejects.toThrow(
+ 'A JavaScript prompt is open on this page: "Your name?"'
+ )
+ expect(execFileMock).not.toHaveBeenCalled()
+
+ await bridge.dialogAccept()
+ expect(callback).toHaveBeenCalledExactlyOnceWith(true, 'def')
+ await expect(bridge.snapshot()).resolves.toBeDefined()
+ })
+
+ it('answers a command that opens a dialog at once, without letting later commands overtake it', async () => {
+ const batches: string[] = []
+ let finishClick = (): void => {}
+ execFileMock.mockImplementation(
+ (_bin: string, args: string[], _opts: unknown, cb: ExecFileCallback) => {
+ const child = createFakeAgentBrowserChild({
+ stdin: { on: vi.fn(), end: (text: string) => batches.push(text) }
+ })
+ if (args.includes('batch') && batches.length === 0) {
+ // The page is blocked, so agent-browser answers only once the dialog closes.
+ queueMicrotask(() => openDialog('confirm', 'Delete everything?'))
+ finishClick = () => cb(null, JSON.stringify({ success: true, data: {} }), '')
+ } else {
+ cb(null, JSON.stringify({ success: true, data: { snapshot: 'tree' } }), '')
+ }
+ return child
+ }
+ )
+
+ const click = bridge.click('@e3')
+ const queuedBehind = bridge.snapshot()
+
+ await expect(click).rejects.toThrow(
+ 'The page opened a JavaScript confirm: "Delete everything?". The command may already have taken effect'
+ )
+ await expect(queuedBehind).rejects.toThrow('The command did not run.')
+ await expect(bridge.snapshot()).rejects.toThrow('A JavaScript confirm is open on this page')
+
+ await bridge.dialogDismiss()
+ const snapshot = bridge.snapshot()
+ await new Promise((resolve) => setTimeout(resolve, 0))
+ expect(batches).toHaveLength(1)
+
+ finishClick()
+ await expect(snapshot).resolves.toBeDefined()
+ expect(batches).toHaveLength(2)
+ })
+
+ it('keeps a dialog on a page an SSH host may not drive out of that host’s errors', async () => {
+ openDialog('alert', 'Desktop-only secret')
+
+ const snapshot = runInRemoteCliBrowserScope(
+ 'workspace',
+ () => bridge.snapshot(),
+ undefined,
+ () => false
+ )
+
+ await expect(snapshot).rejects.toThrow('This page is not browsing through the SSH host')
+ })
+})
diff --git a/src/main/browser/agent-browser-bridge-queue.ts b/src/main/browser/agent-browser-bridge-queue.ts
index f2bc07dec8f..f8adb57e74d 100644
--- a/src/main/browser/agent-browser-bridge-queue.ts
+++ b/src/main/browser/agent-browser-bridge-queue.ts
@@ -9,12 +9,52 @@ import type {
import { runWithRemoteCliPageAdmission } from './remote-cli-page-admission'
import { AGENT_BROWSER_CLEANUP_TIMEOUT_MS } from './agent-browser-bridge-types'
import { releaseHeldPageInput } from './guest-direct-key-input'
+import {
+ getBrowserJavaScriptDialog,
+ onBrowserJavaScriptDialogOpened
+} from './browser-javascript-dialogs'
+import type { BrowserJavaScriptDialog } from '../../shared/browser-javascript-dialog'
import {
captureRemoteCliBrowserRevocation,
captureRemoteCliBrowserScope,
runOutsideRemoteCliBrowserScope
} from '../runtime/desktop-browser-bridge/remote-cli-browser-scope'
+const DIALOG_MESSAGE_QUOTE_MAX_CHARS = 500
+
+// Page-controlled text, so quote it and keep it short.
+function quoteDialogMessage({ message }: BrowserJavaScriptDialog): string {
+ return JSON.stringify(
+ message.length > DIALOG_MESSAGE_QUOTE_MAX_CHARS
+ ? `${message.slice(0, DIALOG_MESSAGE_QUOTE_MAX_CHARS)}…`
+ : message
+ )
+}
+
+function dialogAnswerHint(dialog: BrowserJavaScriptDialog, browserPageId: string): string {
+ const page = `--page ${browserPageId}`
+ return dialog.type === 'prompt'
+ ? `Answer it with \`orca dialog accept ${page} --text <answer>\` or \`orca dialog dismiss ${page}\``
+ : `Answer it with \`orca dialog accept ${page}\` or \`orca dialog dismiss ${page}\``
+}
+
+// Commands block until the page's dialog closes, so agents must answer it first.
+function assertNoJavaScriptDialog(
+ webContentsId: number,
+ browserPageId: string,
+ admit: (id: number) => void
+): void {
+ const open = getBrowserJavaScriptDialog(webContentsId)
+ if (open) {
+ // A host must not read a dialog on a page it may not drive.
+ admit(webContentsId)
+ throw new BrowserError(
+ 'browser_dialog_open',
+ `A JavaScript ${open.type} is open on this page: ${quoteDialogMessage(open)}. ${dialogAnswerHint(open, browserPageId)}, then retry.`
+ )
+ }
+}
+
export abstract class AgentBrowserBridgeQueue extends AgentBrowserBridgeShutdown {
// Serialize tab switches behind commands targeting the current tab.
async tabSwitch(
@@ -65,7 +105,7 @@ export abstract class AgentBrowserBridgeQueue extends AgentBrowserBridgeShutdown
const assertNotRevoked = captureRemoteCliBrowserRevocation()
const origin = captureRemoteCliBrowserScope()
assertNotRevoked()
- const { browserPageId: pageId } = this.resolveCommandTarget(
+ const { browserPageId: pageId, webContentsId } = this.resolveCommandTarget(
worktreeId,
browserPageId,
options.requireScopedTarget
@@ -73,17 +113,26 @@ export abstract class AgentBrowserBridgeQueue extends AgentBrowserBridgeShutdown
if (!browserPageId && options.elements) {
this.assertRefsFromPage(pageId, options.elements)
}
+ // Fail before queueing: the turn ahead may be a command waiting on this very dialog.
+ assertNoJavaScriptDialog(webContentsId, pageId, assertNotRevoked)
const sessionName = `${ORCA_TAB_SESSION_PREFIX}${pageId}`
const agentCommand = this.browserManager.beginAgentCommand(pageId)
- // Dropped commands never execute, so settling also ends the lease; ending twice is harmless.
+ // A dialog blocks the page until it is answered. A command still waiting never runs; one
+ // already running answers its caller now and keeps its turn until it ends, so nothing overtakes it.
+ let running = false
+ let interrupted = false
+ // A started command ends the lease when it finishes; a dropped one when it settles.
+ let started = false
+ let stopWatching = (): void => {}
return new Promise<T>((resolve, reject) => {
let queue = this.commandQueues.get(sessionName)
if (!queue) {
queue = []
this.commandQueues.set(sessionName, queue)
}
- queue.push({
+ const pageQueue = queue
+ const entry = {
execute: () => {
assertNotRevoked()
const run = (): Promise<T> =>
@@ -93,6 +142,23 @@ export abstract class AgentBrowserBridgeQueue extends AgentBrowserBridgeShutdown
(session, target) => {
const gate = (): void => assertNotRevoked(target.webContentsId)
gate()
+ if (interrupted) {
+ throw new BrowserError(
+ 'browser_dialog_opened',
+ 'A dialog interrupted this command'
+ )
+ }
+ assertNoJavaScriptDialog(target.webContentsId, pageId, gate)
+ if (target.webContentsId !== webContentsId) {
+ // The page got a replacement guest while this command waited.
+ const stopWatchingQueued = stopWatching
+ const stopWatchingTarget = watch(target.webContentsId)
+ stopWatching = () => {
+ stopWatchingQueued()
+ stopWatchingTarget()
+ }
+ }
+ running = true
return origin.bridged
? this.runHostCommand(session, target.webContentsId, gate, origin, () =>
execute(session, target)
@@ -101,13 +167,47 @@ export abstract class AgentBrowserBridgeQueue extends AgentBrowserBridgeShutdown
},
options
)
- return origin.run(() => agentCommand.run(run))
+ return origin.run(() => {
+ started = true
+ return agentCommand.run(run)
+ })
},
resolve: resolve as (value: unknown) => void,
reject
- })
+ }
+ const watch = (guestId: number): (() => void) =>
+ onBrowserJavaScriptDialogOpened(guestId, (dialog) => {
+ const waitingAt = pageQueue.indexOf(entry)
+ if (waitingAt !== -1) {
+ pageQueue.splice(waitingAt, 1)
+ }
+ interrupted = true
+ try {
+ assertNotRevoked(guestId)
+ } catch (error) {
+ reject(error)
+ return
+ }
+ const opened = `The page opened a JavaScript ${dialog.type}: ${quoteDialogMessage(dialog)}.`
+ const effect = running
+ ? "The command may already have taken effect, so don't repeat it."
+ : 'The command did not run.'
+ reject(
+ new BrowserError(
+ 'browser_dialog_opened',
+ `${opened} ${effect} ${dialogAnswerHint(dialog, pageId)}.`
+ )
+ )
+ })
+ pageQueue.push(entry)
+ stopWatching = watch(webContentsId)
this.processQueue(sessionName)
- }).finally(agentCommand.end)
+ }).finally(() => {
+ stopWatching()
+ if (!started) {
+ agentCommand.end()
+ }
+ })
}
protected async executeQueuedCommand<T>(
diff --git a/src/main/browser/agent-browser-bridge-utility-commands.ts b/src/main/browser/agent-browser-bridge-utility-commands.ts
index ab4326587cb..cd410643131 100644
--- a/src/main/browser/agent-browser-bridge-utility-commands.ts
+++ b/src/main/browser/agent-browser-bridge-utility-commands.ts
@@ -10,6 +10,11 @@ import {
} from './agent-browser-bridge-types'
import type { BrowserBackResult, BrowserReloadResult } from '../../shared/runtime-types'
import { AgentBrowserBridgeMouseCommands } from './agent-browser-bridge-mouse-commands'
+import {
+ answerBrowserJavaScriptDialog,
+ getBrowserJavaScriptDialog
+} from './browser-javascript-dialogs'
+import { captureRemoteCliBrowserRevocation } from '../runtime/desktop-browser-bridge/remote-cli-browser-scope'
export abstract class AgentBrowserBridgeUtilityCommands extends AgentBrowserBridgeMouseCommands {
async clipboardRead(worktreeId?: string, browserPageId?: string): Promise<unknown> {
@@ -31,20 +36,30 @@ export abstract class AgentBrowserBridgeUtilityCommands extends AgentBrowserBrid
})
}
- async dialogAccept(text?: string, worktreeId?: string, browserPageId?: string): Promise<unknown> {
- return this.enqueueTargetedCommand(worktreeId, browserPageId, async (sessionName) => {
- const args = ['dialog', 'accept']
- if (text) {
- args.push(text)
- }
- return await this.execAgentBrowser(sessionName, args)
- })
+ async dialogAccept(text?: string, worktreeId?: string, browserPageId?: string): Promise<void> {
+ this.answerDialog(true, text, worktreeId, browserPageId)
}
- async dialogDismiss(worktreeId?: string, browserPageId?: string): Promise<unknown> {
- return this.enqueueTargetedCommand(worktreeId, browserPageId, async (sessionName) => {
- return await this.execAgentBrowser(sessionName, ['dialog', 'dismiss'])
- })
+ async dialogDismiss(worktreeId?: string, browserPageId?: string): Promise<void> {
+ this.answerDialog(false, undefined, worktreeId, browserPageId)
+ }
+
+ // Not queued: the page's queued commands wait on this answer.
+ private answerDialog(
+ accept: boolean,
+ text: string | undefined,
+ worktreeId: string | undefined,
+ browserPageId: string | undefined
+ ): void {
+ this.assertCommandAdmission()
+ const assertNotRevoked = captureRemoteCliBrowserRevocation()
+ const { webContentsId } = this.resolveCommandTarget(worktreeId, browserPageId)
+ assertNotRevoked(webContentsId)
+ // Chrome answers an untouched prompt with its default text.
+ const promptText = text ?? getBrowserJavaScriptDialog(webContentsId)?.defaultPromptText ?? ''
+ if (!answerBrowserJavaScriptDialog(webContentsId, { accept, promptText })) {
+ throw new BrowserError('browser_no_dialog', 'No JavaScript dialog is open on this page')
+ }
}
async storageLocalGet(
diff --git a/src/main/browser/agent-browser-process-environment.ts b/src/main/browser/agent-browser-process-environment.ts
index b8710779915..ea2a4c7cff3 100644
--- a/src/main/browser/agent-browser-process-environment.ts
+++ b/src/main/browser/agent-browser-process-environment.ts
@@ -22,6 +22,8 @@ export function createAgentBrowserProcessEnvironment(options: {
if (!env.AGENT_BROWSER_IDLE_TIMEOUT_MS?.trim()) {
env.AGENT_BROWSER_IDLE_TIMEOUT_MS = String(AGENT_BROWSER_IDLE_TIMEOUT_MS)
}
+ // Its auto-accept dropped alert text; Orca keeps every dialog open until someone answers it.
+ env.AGENT_BROWSER_NO_AUTO_DIALOG = '1'
if (options.platform === 'win32' || env.AGENT_BROWSER_SOCKET_DIR?.trim()) {
return { env, ownsSocketDirectory: false }
}
diff --git a/src/main/browser/browser-javascript-dialogs.test.ts b/src/main/browser/browser-javascript-dialogs.test.ts
new file mode 100644
index 00000000000..268f850e48c
--- /dev/null
+++ b/src/main/browser/browser-javascript-dialogs.test.ts
@@ -0,0 +1,130 @@
+import { EventEmitter } from 'node:events'
+import { describe, expect, it, vi } from 'vitest'
+
+import type { BrowserPagePromptRequest } from '../../shared/browser-page-prompt'
+import {
+ answerBrowserJavaScriptDialog,
+ getBrowserJavaScriptDialog,
+ installBrowserJavaScriptDialogs
+} from './browser-javascript-dialogs'
+import { respondToBrowserPagePrompt } from './browser-page-prompts'
+
+type MockContents = Electron.WebContents & EventEmitter & { debugger: EventEmitter }
+
+let nextGuestId = 300
+
+function mockContents(id: number): MockContents {
+ // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the dialog owner only reads id, URL, debugger events and the private dialog events.
+ const contents = new EventEmitter() as MockContents
+ Object.assign(contents, {
+ id,
+ debugger: new EventEmitter(),
+ isDestroyed: () => false,
+ getURL: () => 'https://shop.example/cart',
+ send: vi.fn()
+ })
+ return contents
+}
+
+function setup() {
+ const renderer = mockContents(1)
+ const guest = mockContents(nextGuestId++)
+ const electronSheet = vi.fn()
+ guest.on('-run-dialog', electronSheet)
+ installBrowserJavaScriptDialogs(guest, () => ({
+ browserPageId: 'page-1',
+ renderer
+ }))
+ const openDialog = (
+ dialogType: string,
+ messageText: string,
+ defaultPromptText = '',
+ frame?: { origin: string }
+ ) => {
+ const callback = vi.fn()
+ guest.emit('-run-dialog', { frame, dialogType, messageText, defaultPromptText }, callback)
+ return callback
+ }
+ const shownPrompts = (): BrowserPagePromptRequest[] =>
+ vi
+ .mocked(renderer.send)
+ .mock.calls.filter(([channel]) => channel === 'browser:page-prompt-requested')
+ .map(([, request]) => request)
+ const closedPrompts = () =>
+ vi
+ .mocked(renderer.send)
+ .mock.calls.filter(([channel]) => channel === 'browser:page-prompt-closed')
+ return { renderer, guest, electronSheet, openDialog, shownPrompts, closedPrompts }
+}
+
+describe('browser JavaScript dialogs', () => {
+ it('asks in the page prompt instead of Electron’s window-wide sheet', () => {
+ const { guest, electronSheet, openDialog, shownPrompts } = setup()
+
+ const callback = openDialog('confirm', 'Delete everything?')
+
+ expect(electronSheet).not.toHaveBeenCalled()
+ expect(callback).not.toHaveBeenCalled()
+ expect(getBrowserJavaScriptDialog(guest.id)).toEqual({
+ type: 'confirm',
+ message: 'Delete everything?',
+ defaultPromptText: ''
+ })
+ expect(shownPrompts()).toEqual([
+ expect.objectContaining({
+ kind: 'javascript-dialog',
+ details: {
+ type: 'confirm',
+ message: 'Delete everything?',
+ defaultPromptText: '',
+ origin: 'https://shop.example'
+ }
+ })
+ ])
+ })
+
+ it('names an embedded page that asks, not the site around it', () => {
+ const { openDialog, shownPrompts } = setup()
+
+ openDialog('prompt', 'Re-enter your password', '', { origin: 'https://ads.example' })
+
+ expect(shownPrompts()[0]?.details).toMatchObject({ origin: 'https://ads.example' })
+ })
+
+ it('takes an agent’s prompt answer and closes the page prompt', () => {
+ const { guest, openDialog, closedPrompts } = setup()
+ const callback = openDialog('prompt', 'Your name?', 'def')
+
+ expect(answerBrowserJavaScriptDialog(guest.id, { accept: true, promptText: 'Ada' })).toBe(true)
+
+ expect(callback).toHaveBeenCalledExactlyOnceWith(true, 'Ada')
+ expect(closedPrompts()).toHaveLength(1)
+ expect(getBrowserJavaScriptDialog(guest.id)).toBeNull()
+ expect(answerBrowserJavaScriptDialog(guest.id, { accept: true, promptText: '' })).toBe(false)
+ })
+
+ it('answers the page with what the user chose in the page prompt', async () => {
+ const { renderer, guest, openDialog, shownPrompts } = setup()
+ const callback = openDialog('confirm', 'Leave?')
+
+ await respondToBrowserPagePrompt(renderer, {
+ requestId: shownPrompts()[0].requestId,
+ answer: { accept: false, promptText: '' }
+ })
+
+ expect(callback).toHaveBeenCalledExactlyOnceWith(false, '')
+ expect(getBrowserJavaScriptDialog(guest.id)).toBeNull()
+ })
+
+ it('turns away a second frame’s dialog and keeps the first one answerable', () => {
+ const { guest, openDialog } = setup()
+ const first = openDialog('confirm', 'Delete everything?')
+
+ const second = openDialog('alert', 'From an iframe')
+
+ expect(second).toHaveBeenCalledExactlyOnceWith(false, '')
+ expect(getBrowserJavaScriptDialog(guest.id)?.message).toBe('Delete everything?')
+ expect(answerBrowserJavaScriptDialog(guest.id, { accept: true, promptText: '' })).toBe(true)
+ expect(first).toHaveBeenCalledExactlyOnceWith(true, '')
+ })
+})
diff --git a/src/main/browser/browser-javascript-dialogs.ts b/src/main/browser/browser-javascript-dialogs.ts
new file mode 100644
index 00000000000..486f139fe95
--- /dev/null
+++ b/src/main/browser/browser-javascript-dialogs.ts
@@ -0,0 +1,142 @@
+import type {
+ BrowserJavaScriptDialog,
+ BrowserJavaScriptDialogAnswer
+} from '../../shared/browser-javascript-dialog'
+import {
+ browserPagePromptOrigin,
+ closeBrowserPagePrompts,
+ openBrowserPagePrompt,
+ type BrowserPagePromptTarget
+} from './browser-page-prompts'
+
+type RunDialogInfo = {
+ frame?: { origin?: string } | null
+ dialogType: string
+ messageText: string
+ defaultPromptText: string
+}
+type RunDialogCallback = (success: boolean, userInput: string) => void
+type RunDialogListener = (info: RunDialogInfo, callback: RunDialogCallback) => void
+
+type OpenDialog = {
+ guest: Electron.WebContents
+ dialog: BrowserJavaScriptDialog
+ callback: RunDialogCallback
+}
+
+const openDialogs = new Map<number, OpenDialog>()
+const openedListeners = new Map<number, Set<(dialog: BrowserJavaScriptDialog) => void>>()
+
+export function getBrowserJavaScriptDialog(guestId: number): BrowserJavaScriptDialog | null {
+ return openDialogs.get(guestId)?.dialog ?? null
+}
+
+/** False when the page has no dialog open. */
+export function answerBrowserJavaScriptDialog(
+ guestId: number,
+ answer: BrowserJavaScriptDialogAnswer
+): boolean {
+ const open = openDialogs.get(guestId)
+ if (!open) {
+ return false
+ }
+ openDialogs.delete(guestId)
+ closeBrowserPagePrompts(open.guest, 'javascript-dialog')
+ open.callback(answer.accept, answer.accept ? answer.promptText : '')
+ return true
+}
+
+export function onBrowserJavaScriptDialogOpened(
+ guestId: number,
+ listener: (dialog: BrowserJavaScriptDialog) => void
+): () => void {
+ let listeners = openedListeners.get(guestId)
+ if (!listeners) {
+ listeners = new Set()
+ openedListeners.set(guestId, listeners)
+ }
+ listeners.add(listener)
+ return () => {
+ listeners.delete(listener)
+ if (listeners.size === 0 && openedListeners.get(guestId) === listeners) {
+ openedListeners.delete(guestId)
+ }
+ }
+}
+
+function parseAnswer(value: unknown): BrowserJavaScriptDialogAnswer | undefined {
+ if (
+ typeof value === 'object' &&
+ value !== null &&
+ 'accept' in value &&
+ typeof value.accept === 'boolean' &&
+ 'promptText' in value &&
+ typeof value.promptText === 'string'
+ ) {
+ return { accept: value.accept, promptText: value.promptText }
+ }
+ return undefined
+}
+
+/**
+ * Electron's own `-run-dialog` listener shows a sheet over the whole Orca window and refuses
+ * prompts; agents answered the same dialog over CDP, which left that sheet stuck. Orca owns it
+ * instead, and every answer goes through it: a CDP close event can't say which dialog closed.
+ */
+export function installBrowserJavaScriptDialogs(
+ guest: Electron.WebContents,
+ resolveTarget: () => BrowserPagePromptTarget | null
+): void {
+ const guestId = guest.id
+ // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: WebContents is an EventEmitter; its types list only public events, not Electron's private dialog events.
+ const events = guest as unknown as NodeJS.EventEmitter
+ events.removeAllListeners('-run-dialog')
+
+ const forget = (): void => {
+ if (openDialogs.delete(guestId)) {
+ closeBrowserPagePrompts(guest, 'javascript-dialog')
+ }
+ }
+
+ const onRunDialog: RunDialogListener = (info, callback) => {
+ // One dialog per page: a second frame's dialog while one is showing is dismissed.
+ if (openDialogs.has(guestId)) {
+ callback(false, '')
+ return
+ }
+ const dialog: BrowserJavaScriptDialog = {
+ type:
+ info.dialogType === 'confirm' || info.dialogType === 'prompt' ? info.dialogType : 'alert',
+ message: info.messageText,
+ defaultPromptText: info.dialogType === 'prompt' ? info.defaultPromptText : ''
+ }
+ // Name the frame that asked, as Chrome does, so an embedded page can't speak as the site.
+ const details = {
+ ...dialog,
+ origin: browserPagePromptOrigin(info.frame?.origin ?? guest.getURL())
+ }
+ const open: OpenDialog = { guest, dialog, callback }
+ openDialogs.set(guestId, open)
+ // With no window to ask in, the dialog waits for an agent or a phone to answer it.
+ openBrowserPagePrompt({
+ kind: 'javascript-dialog',
+ requester: guest,
+ target: resolveTarget(),
+ details: () => details,
+ waitsForAnswer: true,
+ parseAnswer,
+ settle: (answer) => {
+ if (openDialogs.get(guestId) === open) {
+ answerBrowserJavaScriptDialog(guestId, answer ?? { accept: false, promptText: '' })
+ }
+ }
+ })
+ for (const listener of openedListeners.get(guestId) ?? []) {
+ listener(dialog)
+ }
+ }
+
+ events.on('-run-dialog', onRunDialog)
+ events.on('-cancel-dialogs', forget)
+ guest.once('destroyed', forget)
+}
diff --git a/src/main/browser/browser-page-prompts.ts b/src/main/browser/browser-page-prompts.ts
index 873c43d3c37..334146bbae7 100644
--- a/src/main/browser/browser-page-prompts.ts
+++ b/src/main/browser/browser-page-prompts.ts
@@ -28,7 +28,7 @@ type PendingPrompt = {
details: () => unknown
parseAnswer: (value: unknown) => unknown
settles: ((value: unknown) => ReturnType<SettlePrompt<unknown>>)[]
- timer: ReturnType<typeof setTimeout>
+ timer: ReturnType<typeof setTimeout> | undefined
unwatch: (() => void)[]
}
@@ -150,6 +150,8 @@ export function openBrowserPagePrompt<K extends BrowserPagePromptKind>(args: {
target: BrowserPagePromptTarget | null
details: () => BrowserPagePromptDetails<K>
coalesceKey?: string
+ /** For the page's own dialogs: no timeout, and asked even when other prompts are open or quieted. */
+ waitsForAnswer?: boolean
parseAnswer: (value: unknown) => BrowserPagePromptAnswer<K> | undefined
settle: SettlePrompt<BrowserPagePromptAnswer<K>>
}): BrowserPagePromptOpening {
@@ -161,26 +163,28 @@ export function openBrowserPagePrompt<K extends BrowserPagePromptKind>(args: {
if (context?.renderer.isDestroyed()) {
return 'no-window'
}
- if (isBrowserPagePromptQuiet(requester)) {
+ if (!args.waitsForAnswer && isBrowserPagePromptQuiet(requester)) {
return 'refused'
}
- for (const pending of pendingPrompts.values()) {
- const samePage =
- pending.requester.id === requester.id ||
- (context !== null && pending.browserPageId === context.browserPageId)
- if (!samePage) {
- continue
- }
- if (
- args.coalesceKey !== undefined &&
- pending.requester.id === requester.id &&
- pending.kind === args.kind &&
- pending.coalesceKey === args.coalesceKey
- ) {
- pending.settles.push(bindSettle(args.parseAnswer, args.settle))
- return 'prompting'
+ if (!args.waitsForAnswer) {
+ for (const pending of pendingPrompts.values()) {
+ const samePage =
+ pending.requester.id === requester.id ||
+ (context !== null && pending.browserPageId === context.browserPageId)
+ if (!samePage) {
+ continue
+ }
+ if (
+ args.coalesceKey !== undefined &&
+ pending.requester.id === requester.id &&
+ pending.kind === args.kind &&
+ pending.coalesceKey === args.coalesceKey
+ ) {
+ pending.settles.push(bindSettle(args.parseAnswer, args.settle))
+ return 'prompting'
+ }
+ return 'refused'
}
- return 'refused'
}
const requestId = randomUUID()
const pending: PendingPrompt = {
@@ -192,7 +196,9 @@ export function openBrowserPagePrompt<K extends BrowserPagePromptKind>(args: {
details: args.details,
parseAnswer: args.parseAnswer,
settles: [bindSettle(args.parseAnswer, args.settle)],
- timer: setTimeout(() => closePrompt(requestId, true), BROWSER_PAGE_PROMPT_TIMEOUT_MS),
+ timer: args.waitsForAnswer
+ ? undefined
+ : setTimeout(() => closePrompt(requestId, true), BROWSER_PAGE_PROMPT_TIMEOUT_MS),
unwatch: [closeWhenGone(requestId, requester, { orNavigates: true })]
}
pendingPrompts.set(requestId, pending)
@@ -239,6 +245,18 @@ export async function respondToBrowserPagePrompt(
return runSettles(pending, response.answer)
}
+/** Closes a page's prompts of one kind that were answered some other way. */
+export function closeBrowserPagePrompts(
+ requester: Electron.WebContents,
+ kind: BrowserPagePromptKind
+): void {
+ for (const [requestId, pending] of pendingPrompts) {
+ if (pending.requester === requester && pending.kind === kind) {
+ closePrompt(requestId, false)
+ }
+ }
+}
+
export function cancelBrowserPagePrompts(browserPageId: string): void {
for (const [requestId, pending] of pendingPrompts) {
if (pending.browserPageId === browserPageId) {
diff --git a/src/main/browser/browser-screencast-cdp-events.ts b/src/main/browser/browser-screencast-cdp-events.ts
index f3cddf86853..d2c4accbfdd 100644
--- a/src/main/browser/browser-screencast-cdp-events.ts
+++ b/src/main/browser/browser-screencast-cdp-events.ts
@@ -9,6 +9,7 @@ import type {
PendingScreencastFrame
} from './browser-screencast-stream-types'
import { isLiveFrameCompatibleWithViewport } from './browser-screencast-viewport-fit'
+import type { BrowserJavaScriptDialog } from '../../shared/browser-javascript-dialog'
type BrowserScreencastMessageHandlerDeps = {
dbg: WebContents['debugger']
@@ -22,7 +23,8 @@ type BrowserScreencastMessageHandlerDeps = {
bumpSnapshotGeneration: () => void
/** True while guest frames must be dropped pending re-emulation. */
observeGuestViewSize: (metadata: BrowserScreencastFrameMetadata) => boolean
- setDialogOpen: (open: boolean) => void
+ /** The page's dialog Orca still holds; a CDP close can be a second frame's turned-away one. */
+ openDialog: () => BrowserJavaScriptDialog | null
}
export function createBrowserScreencastMessageHandler(
@@ -31,7 +33,7 @@ export function createBrowserScreencastMessageHandler(
const { dbg, options, isClosed, isStopping, queueFrame, ackScreencastFrame } = deps
const { scheduleNavigationFrameCapture, clearNavigationCaptureTimer, bumpSnapshotGeneration } =
deps
- const { setDialogOpen, observeGuestViewSize } = deps
+ const { observeGuestViewSize, openDialog } = deps
return (_event: unknown, method: string, params: unknown): void => {
if (isClosed()) {
@@ -43,7 +45,6 @@ export function createBrowserScreencastMessageHandler(
if (method === 'Page.javascriptDialogOpening') {
const payload =
params && typeof params === 'object' ? (params as Record<string, unknown>) : {}
- setDialogOpen(true)
options.onEvent?.({
type: 'dialog',
dialogType: typeof payload.type === 'string' ? payload.type : 'alert',
@@ -52,8 +53,12 @@ export function createBrowserScreencastMessageHandler(
return
}
if (method === 'Page.javascriptDialogClosed') {
- setDialogOpen(false)
- options.onEvent?.({ type: 'dialogClosed' })
+ const open = openDialog()
+ options.onEvent?.(
+ open
+ ? { type: 'dialog', dialogType: open.type, message: open.message }
+ : { type: 'dialogClosed' }
+ )
return
}
if (method === 'Page.frameNavigated') {
diff --git a/src/main/browser/browser-screencast-dialog-settlement.test.ts b/src/main/browser/browser-screencast-dialog-settlement.test.ts
deleted file mode 100644
index e6392ae9e21..00000000000
--- a/src/main/browser/browser-screencast-dialog-settlement.test.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { startBrowserScreencast } from './browser-screencast-stream'
-import { createMockScreencastWebContents } from './browser-screencast-web-contents-test-double'
-
-const OPTIONS = {
- format: 'jpeg' as const,
- quality: 70,
- maxWidth: 1440,
- maxHeight: 1200,
- everyNthFrame: 1,
- minFrameIntervalMs: 0
-}
-
-function openDialog(
- webContents: ReturnType<typeof createMockScreencastWebContents>,
- type = 'alert',
- message = 'first'
-): void {
- webContents.debugger.emit('message', {}, 'Page.javascriptDialogOpening', { type, message })
-}
-
-/** Debugger commands are issued on a microtask. */
-async function flushMicrotasks(): Promise<void> {
- await Promise.resolve()
- await Promise.resolve()
-}
-
-function dialogCalls(webContents: ReturnType<typeof createMockScreencastWebContents>): unknown[][] {
- return webContents.debugger.sendCommand.mock.calls.filter(
- (call) => call[0] === 'Page.handleJavaScriptDialog'
- )
-}
-
-describe('the browser screencast settles the dialog it reported', () => {
- it('answers the open dialog on its own debugger session', async () => {
- const webContents = createMockScreencastWebContents()
- const session = await startBrowserScreencast(webContents as never, {
- ...OPTIONS,
- onFrame: vi.fn(),
- onEvent: vi.fn()
- })
-
- openDialog(webContents)
- await expect(session.settleDialog(true)).resolves.toBe(true)
-
- expect(dialogCalls(webContents)).toEqual([['Page.handleJavaScriptDialog', { accept: true }]])
-
- session.stop()
- await session.done
- })
-
- it('carries a prompt answer and a dismissal', async () => {
- const webContents = createMockScreencastWebContents()
- const session = await startBrowserScreencast(webContents as never, {
- ...OPTIONS,
- onFrame: vi.fn()
- })
-
- openDialog(webContents, 'prompt', 'name?')
- await expect(session.settleDialog(true, 'Ada')).resolves.toBe(true)
- webContents.debugger.emit('message', {}, 'Page.javascriptDialogClosed', {})
- openDialog(webContents, 'confirm', 'sure?')
- await expect(session.settleDialog(false)).resolves.toBe(true)
-
- expect(dialogCalls(webContents)).toEqual([
- ['Page.handleJavaScriptDialog', { accept: true, promptText: 'Ada' }],
- ['Page.handleJavaScriptDialog', { accept: false }]
- ])
-
- session.stop()
- await session.done
- })
-
- it('reports no dialog rather than answering one that is not open', async () => {
- const webContents = createMockScreencastWebContents()
- const session = await startBrowserScreencast(webContents as never, {
- ...OPTIONS,
- onFrame: vi.fn()
- })
-
- await expect(session.settleDialog(true)).resolves.toBe(false)
- openDialog(webContents)
- webContents.debugger.emit('message', {}, 'Page.javascriptDialogClosed', {})
- await expect(session.settleDialog(true)).resolves.toBe(false)
-
- expect(dialogCalls(webContents)).toEqual([])
-
- session.stop()
- await session.done
- })
-
- it('sends one command for two answers to the same dialog', async () => {
- const webContents = createMockScreencastWebContents()
- const session = await startBrowserScreencast(webContents as never, {
- ...OPTIONS,
- onFrame: vi.fn()
- })
-
- openDialog(webContents, 'confirm', 'twice?')
- const [first, second] = await Promise.all([
- session.settleDialog(true),
- session.settleDialog(true)
- ])
-
- await flushMicrotasks()
- expect([first, second]).toEqual([true, true])
- expect(dialogCalls(webContents)).toEqual([['Page.handleJavaScriptDialog', { accept: true }]])
-
- session.stop()
- await session.done
- })
-
- it("keeps a failed answer from clearing the next dialog's armed one", async () => {
- const webContents = createMockScreencastWebContents()
- const answers: { reject: (error: Error) => void }[] = []
- webContents.debugger.sendCommand.mockImplementation(async (method: string) => {
- if (method !== 'Page.handleJavaScriptDialog') {
- return {}
- }
- return new Promise((_resolve, reject) => {
- answers.push({ reject })
- })
- })
- const session = await startBrowserScreencast(webContents as never, {
- ...OPTIONS,
- onFrame: vi.fn()
- })
-
- openDialog(webContents, 'confirm', 'A')
- const answeringA = session.settleDialog(true)
- webContents.debugger.emit('message', {}, 'Page.javascriptDialogClosed', {})
- openDialog(webContents, 'confirm', 'B')
- const answeringB = session.settleDialog(true)
- await flushMicrotasks()
- expect(dialogCalls(webContents)).toHaveLength(2)
-
- answers[0]?.reject(new Error('No dialog is showing'))
- await expect(answeringA).rejects.toThrow('No dialog is showing')
- void session.settleDialog(true)
- await flushMicrotasks()
- expect(dialogCalls(webContents)).toHaveLength(2)
-
- answers[1]?.reject(new Error('stop'))
- await expect(answeringB).rejects.toThrow('stop')
- })
-
- it('dismisses a dialog still open when the stream stops, so no later session inherits it', async () => {
- const webContents = createMockScreencastWebContents()
- const session = await startBrowserScreencast(webContents as never, {
- ...OPTIONS,
- onFrame: vi.fn()
- })
-
- openDialog(webContents, 'confirm', 'still up')
- session.stop()
- await session.done
-
- const methods = webContents.debugger.sendCommand.mock.calls.map((call) => call[0])
- expect(dialogCalls(webContents)).toEqual([['Page.handleJavaScriptDialog', { accept: false }]])
- expect(methods.indexOf('Page.handleJavaScriptDialog')).toBeLessThan(
- methods.indexOf('Page.stopScreencast')
- )
- })
-
- it('leaves the page alone when it stops with no dialog open', async () => {
- const webContents = createMockScreencastWebContents()
- const session = await startBrowserScreencast(webContents as never, {
- ...OPTIONS,
- onFrame: vi.fn()
- })
-
- openDialog(webContents)
- webContents.debugger.emit('message', {}, 'Page.javascriptDialogClosed', {})
- session.stop()
- await session.done
-
- expect(dialogCalls(webContents)).toEqual([])
- })
-
- it('raises every dialog of the subscription, not just the first', async () => {
- const webContents = createMockScreencastWebContents()
- const onEvent = vi.fn()
- const session = await startBrowserScreencast(webContents as never, {
- ...OPTIONS,
- onFrame: vi.fn(),
- onEvent
- })
-
- openDialog(webContents, 'alert', 'first')
- await session.settleDialog(true)
- webContents.debugger.emit('message', {}, 'Page.javascriptDialogClosed', {})
- openDialog(webContents, 'confirm', 'second')
- await session.settleDialog(true)
-
- expect(onEvent.mock.calls.map(([event]) => event)).toEqual([
- { type: 'dialog', dialogType: 'alert', message: 'first' },
- { type: 'dialogClosed' },
- { type: 'dialog', dialogType: 'confirm', message: 'second' }
- ])
-
- session.stop()
- await session.done
- })
-})
diff --git a/src/main/browser/browser-screencast-lifecycle.test.ts b/src/main/browser/browser-screencast-lifecycle.test.ts
index fae34c53d3a..85b5f902c05 100644
--- a/src/main/browser/browser-screencast-lifecycle.test.ts
+++ b/src/main/browser/browser-screencast-lifecycle.test.ts
@@ -142,7 +142,7 @@ describe('browser screencast lifecycle', () => {
clearNavigationCaptureTimer: vi.fn(),
bumpSnapshotGeneration: vi.fn(),
observeGuestViewSize: () => false,
- setDialogOpen: vi.fn()
+ openDialog: () => null
})
handler({}, 'Page.screencastFrame', { sessionId: 42, data: '' })
diff --git a/src/main/browser/browser-screencast-live-frame-allocation.test.ts b/src/main/browser/browser-screencast-live-frame-allocation.test.ts
index daf938794fb..c560d578829 100644
--- a/src/main/browser/browser-screencast-live-frame-allocation.test.ts
+++ b/src/main/browser/browser-screencast-live-frame-allocation.test.ts
@@ -56,7 +56,7 @@ function createLiveFrameRoute(
clearNavigationCaptureTimer: () => {},
bumpSnapshotGeneration: () => {},
observeGuestViewSize: () => false,
- setDialogOpen: () => {}
+ openDialog: () => null
})
return {
pacer,
diff --git a/src/main/browser/browser-screencast-stream-types.ts b/src/main/browser/browser-screencast-stream-types.ts
index b9a1974bc74..a692d32d025 100644
--- a/src/main/browser/browser-screencast-stream-types.ts
+++ b/src/main/browser/browser-screencast-stream-types.ts
@@ -34,8 +34,6 @@ export type BrowserScreencastSession = {
done: Promise<void>
updateViewport: (viewport: BrowserScreencastViewport) => Promise<void>
updateFrameBudget: (budget: BrowserScreencastFrameBudget) => Promise<void>
- /** Answers on the reporting CDP session; returns false if no dialog is open. */
- settleDialog: (accept: boolean, promptText?: string) => Promise<boolean>
}
export type BrowserScreencastEvent =
diff --git a/src/main/browser/browser-screencast-stream.test.ts b/src/main/browser/browser-screencast-stream.test.ts
index 79de252769c..25f5da14eb1 100644
--- a/src/main/browser/browser-screencast-stream.test.ts
+++ b/src/main/browser/browser-screencast-stream.test.ts
@@ -1,8 +1,10 @@
import { Buffer } from 'node:buffer'
+import { EventEmitter } from 'node:events'
import { describe, expect, it, vi } from 'vitest'
import { decodeBrowserScreencastFrame } from '../../shared/browser-screencast-protocol'
import { startBrowserScreencast } from './browser-screencast-stream'
+import { installBrowserJavaScriptDialogs } from './browser-javascript-dialogs'
import { createMockScreencastWebContents as createMockWebContents } from './browser-screencast-web-contents-test-double'
function jpegWithSize(width: number, height: number): Buffer {
@@ -748,6 +750,45 @@ describe('startBrowserScreencast', () => {
await session.done
})
+ it('keeps the phone card on the dialog Orca holds, and dismisses it when the last viewer leaves', async () => {
+ const webContents = Object.assign(new EventEmitter(), createMockWebContents(), {
+ id: 501,
+ getURL: () => 'https://example.com'
+ })
+ // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the dialog owner reads only id, URL and the emitter; the double carries all three.
+ installBrowserJavaScriptDialogs(webContents as never, () => null)
+ const onEvent = vi.fn()
+ const session = await startBrowserScreencast(webContents as never, {
+ format: 'jpeg',
+ quality: 70,
+ maxWidth: 1440,
+ maxHeight: 1200,
+ everyNthFrame: 2,
+ minFrameIntervalMs: 0,
+ onFrame: vi.fn(),
+ onEvent
+ })
+ const answer = vi.fn()
+ webContents.emit(
+ '-run-dialog',
+ { dialogType: 'confirm', messageText: 'Continue?', defaultPromptText: '' },
+ answer
+ )
+
+ // The turned-away dialog's close names no dialog.
+ webContents.debugger.emit('message', {}, 'Page.javascriptDialogClosed', {})
+
+ expect(onEvent).toHaveBeenLastCalledWith({
+ type: 'dialog',
+ dialogType: 'confirm',
+ message: 'Continue?'
+ })
+ // The last viewer leaving dismisses it, so a later session isn't blocked behind it.
+ session.stop()
+ await session.done
+ expect(answer).toHaveBeenCalledExactlyOnceWith(false, '')
+ })
+
it('applies the client viewport before the screencast starts', async () => {
const webContents = createMockWebContents()
diff --git a/src/main/browser/browser-screencast-stream.ts b/src/main/browser/browser-screencast-stream.ts
index 2fb24a4688f..a0e6aebdba8 100644
--- a/src/main/browser/browser-screencast-stream.ts
+++ b/src/main/browser/browser-screencast-stream.ts
@@ -6,6 +6,10 @@ import { sendDebuggerCommand } from './browser-screencast-debugger-command'
import { createBrowserScreencastDeviceMetrics } from './browser-screencast-device-metrics'
import { createBrowserScreencastFramePacer } from './browser-screencast-frame-pacer'
import { createBrowserScreencastSnapshotCapture } from './browser-screencast-snapshot-capture'
+import {
+ answerBrowserJavaScriptDialog,
+ getBrowserJavaScriptDialog
+} from './browser-javascript-dialogs'
import {
clampScreencastViewportToGuestView,
isEmbedderSizedScreencastGuest,
@@ -42,10 +46,6 @@ export async function startBrowserScreencast(
let closed = false
let stopping = false
- let dialogOpen = false
- // Reuse the in-flight answer; a duplicate command could settle the next dialog unseen.
- let dialogSettlement: Promise<boolean> | null = null
- let dialogGeneration = 0
let resolveDone!: () => void
// Serializes viewport and frame-budget changes against the snapshot capture they trigger.
let pendingUpdate = Promise.resolve()
@@ -122,11 +122,7 @@ export async function startBrowserScreencast(
// Reject old-layout crops until queued viewport metrics have landed.
return appliedEmulationGeneration < emulationGeneration
},
- setDialogOpen: (open: boolean) => {
- dialogOpen = open
- dialogGeneration += 1
- dialogSettlement = null
- }
+ openDialog: () => getBrowserJavaScriptDialog(webContents.id)
})
const reemulate = (): Promise<void> => {
@@ -159,8 +155,6 @@ export async function startBrowserScreencast(
return
}
closed = true
- dialogOpen = false
- dialogSettlement = null
snapshotCapture.clearNavigationCaptureTimer()
framePacer.clearPending()
dbg.removeListener('message', handleMessage as never)
@@ -203,29 +197,6 @@ export async function startBrowserScreencast(
}
return {
- settleDialog: (accept: boolean, promptText?: string) => {
- if (!dialogOpen) {
- return Promise.resolve(false)
- }
- if (dialogSettlement !== null) {
- return dialogSettlement
- }
- const generation = dialogGeneration
- const settlement = sendDebuggerCommand(dbg, 'Page.handleJavaScriptDialog', {
- accept,
- ...(promptText === undefined ? {} : { promptText })
- })
- .then(() => true)
- .catch((error: unknown) => {
- // A failed answer must not clear a newer dialog's in-flight answer.
- if (dialogGeneration === generation) {
- dialogSettlement = null
- }
- throw error
- })
- dialogSettlement = settlement
- return settlement
- },
updateViewport: (viewport: BrowserScreencastViewport) => {
if (!closed && !stopping) {
requestedViewport = { ...viewport }
@@ -258,14 +229,7 @@ export async function startBrowserScreencast(
void (async () => {
await pendingUpdate.catch(() => {})
// Dismiss before releasing this CDP session; a replacement may block while the dialog is open.
- if (dialogOpen) {
- dialogOpen = false
- const pending = dialogSettlement
- dialogSettlement = null
- await (
- pending ?? sendDebuggerCommand(dbg, 'Page.handleJavaScriptDialog', { accept: false })
- ).catch(() => {})
- }
+ answerBrowserJavaScriptDialog(webContents.id, { accept: false, promptText: '' })
await sendDebuggerCommand(dbg, 'Page.stopScreencast').catch(() => {})
if (deviceMetrics.isOverridden()) {
await deviceMetrics.clear().catch(() => {})
diff --git a/src/main/browser/offscreen-browser-backend.ts b/src/main/browser/offscreen-browser-backend.ts
index 3583d0019af..c03362abf89 100644
--- a/src/main/browser/offscreen-browser-backend.ts
+++ b/src/main/browser/offscreen-browser-backend.ts
@@ -7,6 +7,7 @@ import type { BrowserBackend, BrowserBackendCreateTab } from './browser-backend'
import type { BrowserManager } from './browser-manager'
import type { AgentBrowserBridge } from './agent-browser-bridge'
import { browserSessionRegistry } from './browser-session-registry'
+import { installBrowserJavaScriptDialogs } from './browser-javascript-dialogs'
import type { ServeBrowserPageState } from '../runtime/serve-browser-tab-layout'
// orca serve has no renderer for webviews; hidden BrowserWindows host its pages.
@@ -59,6 +60,8 @@ export class OffscreenBrowserBackend implements BrowserBackend {
})
this.windowsByPageId.set(browserPageId, win)
+ // Server pages have no window to ask in; agents and phones answer their dialogs.
+ installBrowserJavaScriptDialogs(win.webContents, () => null)
// Do not wait for navigation: slow or failed loads must leave an operable tab.
const registered = this.browserManager.registerOffscreenGuest({
diff --git a/src/main/runtime/browser-dialog-settlement.test.ts b/src/main/runtime/browser-dialog-settlement.test.ts
deleted file mode 100644
index c776f86c9d8..00000000000
--- a/src/main/runtime/browser-dialog-settlement.test.ts
+++ /dev/null
@@ -1,127 +0,0 @@
-/** Modal replies must use the reporting CDP session; a fresh renderer-bound client blocks behind the dialog. */
-import { describe, expect, it, vi } from 'vitest'
-
-vi.mock('electron', () => ({
- webContents: { fromId: () => ({ isDestroyed: () => false }) }
-}))
-
-import { RuntimeBrowserDialogs } from './browser/browser-dialogs'
-import { settleBrowserDialogOnLiveScreencast } from './browser-dialog-settlement'
-import type { ActiveBrowserScreencastPage } from './browser/browser-screencast-contracts'
-import type { BrowserScreencastSession } from '../browser/browser-screencast-stream-types'
-
-const PAGE_ID = 'page-1'
-
-function streamingPage(session: BrowserScreencastSession): ActiveBrowserScreencastPage {
- return {
- format: 'jpeg',
- session,
- started: Promise.resolve(session),
- stopping: false,
- subscribers: new Map(),
- viewportOwnerSubscriptionId: null,
- appliedBudget: {
- quality: 72,
- maxWidth: 768,
- maxHeight: 1133,
- everyNthFrame: 1,
- minFrameIntervalMs: 100
- }
- }
-}
-
-function createCommands(settleDialog: (accept: boolean, promptText?: string) => Promise<boolean>) {
- const bridge = {
- getRegisteredTabs: () => new Map([[PAGE_ID, 7]]),
- dialogAccept: vi.fn(async () => ({ via: 'bridge' })),
- dialogDismiss: vi.fn(async () => ({ via: 'bridge' }))
- }
- const activeScreencastsByPageId = new Map<string, ActiveBrowserScreencastPage>()
- const commands = new RuntimeBrowserDialogs(
- {
- resolveBrowserCommandTarget: async (params) => ({ browserPageId: params.page }),
- requireAgentBrowserBridge: () => bridge
- },
- {
- settleDialog: (pageId, accept, promptText) =>
- settleBrowserDialogOnLiveScreencast(activeScreencastsByPageId, pageId, accept, promptText)
- }
- )
- const registerStream = (): void => {
- activeScreencastsByPageId.set(
- PAGE_ID,
- streamingPage({
- stop: () => {},
- done: Promise.resolve(),
- updateViewport: async () => {},
- updateFrameBudget: async () => {},
- settleDialog
- })
- )
- }
- return { bridge, commands, registerStream }
-}
-
-describe('a dialog reply goes to the stream that reported it', () => {
- it('accepts through the live stream instead of the agent-browser bridge', async () => {
- const settleDialog = vi.fn(async () => true)
- const { bridge, commands, registerStream } = createCommands(settleDialog)
- registerStream()
-
- const result = await commands.browserDialogAccept({ page: PAGE_ID, text: 'Ada' })
-
- expect(settleDialog).toHaveBeenCalledWith(true, 'Ada')
- expect(bridge.dialogAccept).not.toHaveBeenCalled()
- expect(result).toEqual({ accepted: true })
- })
-
- it('dismisses through the live stream instead of the agent-browser bridge', async () => {
- const settleDialog = vi.fn(async () => true)
- const { bridge, commands, registerStream } = createCommands(settleDialog)
- registerStream()
-
- const result = await commands.browserDialogDismiss({ page: PAGE_ID })
-
- expect(settleDialog).toHaveBeenCalledWith(false, undefined)
- expect(bridge.dialogDismiss).not.toHaveBeenCalled()
- expect(result).toEqual({ accepted: false })
- })
-
- it('falls back to the bridge when the stream has no dialog open', async () => {
- const settleDialog = vi.fn(async () => false)
- const { bridge, commands, registerStream } = createCommands(settleDialog)
- registerStream()
-
- await commands.browserDialogAccept({ page: PAGE_ID })
-
- expect(settleDialog).toHaveBeenCalledWith(true, undefined)
- expect(bridge.dialogAccept).toHaveBeenCalledTimes(1)
- })
-
- it('falls back to the bridge when no stream is live on the page', async () => {
- const settleDialog = vi.fn(async () => true)
- const { bridge, commands } = createCommands(settleDialog)
-
- await commands.browserDialogDismiss({ page: PAGE_ID })
-
- expect(settleDialog).not.toHaveBeenCalled()
- expect(bridge.dialogDismiss).toHaveBeenCalledTimes(1)
- })
-
- it('answers one shape whichever path ran, so a viewer cannot change the reply', async () => {
- const streamed = createCommands(vi.fn(async () => true))
- streamed.registerStream()
- const bridged = createCommands(vi.fn(async () => false))
- bridged.registerStream()
-
- expect(await streamed.commands.browserDialogAccept({ page: PAGE_ID })).toEqual(
- await bridged.commands.browserDialogAccept({ page: PAGE_ID })
- )
- expect(await streamed.commands.browserDialogDismiss({ page: PAGE_ID })).toEqual(
- await bridged.commands.browserDialogDismiss({ page: PAGE_ID })
- )
- expect(bridged.bridge.dialogAccept).toHaveBeenCalledTimes(1)
- expect(bridged.bridge.dialogDismiss).toHaveBeenCalledTimes(1)
- expect(streamed.bridge.dialogAccept).not.toHaveBeenCalled()
- })
-})
diff --git a/src/main/runtime/browser-dialog-settlement.ts b/src/main/runtime/browser-dialog-settlement.ts
deleted file mode 100644
index 3014c5faf07..00000000000
--- a/src/main/runtime/browser-dialog-settlement.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import type { ActiveBrowserScreencastPage } from './browser/browser-screencast-contracts'
-
-/** Keep JSON results stable across streaming and agent-browser paths, independent of CLI payload versions. */
-export type BrowserDialogResult = { accepted: boolean }
-
-export function browserDialogSettledResult(accepted: boolean): BrowserDialogResult {
- return { accepted }
-}
-
-/** Chromium accepts modal replies only from the reporting CDP session.
- * A fresh renderer-bound agent-browser client blocks behind the dialog; false leaves fallback to the caller. */
-export async function settleBrowserDialogOnLiveScreencast(
- activeScreencastsByPageId: ReadonlyMap<string, ActiveBrowserScreencastPage>,
- browserPageId: string | undefined,
- accept: boolean,
- promptText?: string
-): Promise<boolean> {
- if (browserPageId === undefined) {
- return false
- }
- const session = activeScreencastsByPageId.get(browserPageId)?.session
- if (!session) {
- return false
- }
- return session.settleDialog(accept, promptText)
-}
diff --git a/src/main/runtime/browser/browser-commands.ts b/src/main/runtime/browser/browser-commands.ts
index 0938c4a68cd..58fc54cc8ed 100644
--- a/src/main/runtime/browser/browser-commands.ts
+++ b/src/main/runtime/browser/browser-commands.ts
@@ -114,7 +114,7 @@ export class RuntimeBrowserCommands {
const close = new RuntimeBrowserTabClose(queries, host, targets)
const profiles = new RuntimeBrowserProfiles(host, targets, catalog)
const screencasts = new RuntimeBrowserScreencasts(host, targets, catalog)
- const dialogs = new RuntimeBrowserDialogs(targets, screencasts)
+ const dialogs = new RuntimeBrowserDialogs(targets)
this.browserProfileDetectBrowsers = profiles.browserProfileDetectBrowsers.bind(profiles)
this.browserProfileImportFromBrowser = profiles.browserProfileImportFromBrowser.bind(profiles)
this.browserProfileClearGoogleCookies = profiles.browserProfileClearGoogleCookies.bind(profiles)
diff --git a/src/main/runtime/browser/browser-dialogs.ts b/src/main/runtime/browser/browser-dialogs.ts
index 8ab23e2aef7..030fc55efc9 100644
--- a/src/main/runtime/browser/browser-dialogs.ts
+++ b/src/main/runtime/browser/browser-dialogs.ts
@@ -1,37 +1,31 @@
import type { AgentBrowserBridge } from '../../browser/agent-browser-bridge'
-import type { RuntimeBrowserScreencasts } from './browser-screencasts'
-import { browserDialogSettledResult, type BrowserDialogResult } from '../browser-dialog-settlement'
import type { BrowserCommandTargetParams } from './browser-command-contracts'
import type { RuntimeBrowserCommandTargets } from './browser-command-targets'
+/** Keep JSON results stable across CLI payload versions. */
+export type BrowserDialogResult = { accepted: boolean }
+
type BrowserDialogTargets = Pick<RuntimeBrowserCommandTargets, 'resolveBrowserCommandTarget'> & {
requireAgentBrowserBridge(): Pick<AgentBrowserBridge, 'dialogAccept' | 'dialogDismiss'>
}
export class RuntimeBrowserDialogs {
- constructor(
- private readonly targets: BrowserDialogTargets,
- private readonly screencasts: Pick<RuntimeBrowserScreencasts, 'settleDialog'>
- ) {}
+ constructor(private readonly targets: BrowserDialogTargets) {}
async browserDialogAccept(
params: { text?: string } & BrowserCommandTargetParams
): Promise<BrowserDialogResult> {
const target = await this.targets.resolveBrowserCommandTarget(params)
- if (!(await this.screencasts.settleDialog(target.browserPageId, true, params.text))) {
- await this.targets
- .requireAgentBrowserBridge()
- .dialogAccept(params.text, target.worktreeId, target.browserPageId)
- }
- return browserDialogSettledResult(true)
+ await this.targets
+ .requireAgentBrowserBridge()
+ .dialogAccept(params.text, target.worktreeId, target.browserPageId)
+ return { accepted: true }
}
async browserDialogDismiss(params: BrowserCommandTargetParams): Promise<BrowserDialogResult> {
const target = await this.targets.resolveBrowserCommandTarget(params)
- if (!(await this.screencasts.settleDialog(target.browserPageId, false))) {
- await this.targets
- .requireAgentBrowserBridge()
- .dialogDismiss(target.worktreeId, target.browserPageId)
- }
- return browserDialogSettledResult(false)
+ await this.targets
+ .requireAgentBrowserBridge()
+ .dialogDismiss(target.worktreeId, target.browserPageId)
+ return { accepted: false }
}
}
diff --git a/src/main/runtime/browser/browser-screencast-contracts.ts b/src/main/runtime/browser/browser-screencast-contracts.ts
index f85f2eb4af9..72834db9f73 100644
--- a/src/main/runtime/browser/browser-screencast-contracts.ts
+++ b/src/main/runtime/browser/browser-screencast-contracts.ts
@@ -24,8 +24,8 @@ export type BrowserScreencastParams = {
export type BrowserScreencastStartResult = {
subscriptionId: string
ready: Extract<BrowserScreencastResult, { type: 'ready' }>
- // Shared-page budget/dialog ownership must not leak through subscriber handles.
- session: Omit<BrowserScreencastSession, 'updateFrameBudget' | 'settleDialog'>
+ // Shared-page budget ownership must not leak through subscriber handles.
+ session: Omit<BrowserScreencastSession, 'updateFrameBudget'>
// Replay the joining snapshot once the caller's pre-ready gate opens.
flushPendingFrame: () => void
}
diff --git a/src/main/runtime/browser/browser-screencasts.test.ts b/src/main/runtime/browser/browser-screencasts.test.ts
index 9d19a8b91ee..5da8fc75a01 100644
--- a/src/main/runtime/browser/browser-screencasts.test.ts
+++ b/src/main/runtime/browser/browser-screencasts.test.ts
@@ -33,8 +33,7 @@ function createSession() {
stop: vi.fn(() => close()),
done,
updateViewport: async () => {},
- updateFrameBudget: async () => {},
- settleDialog: async () => false
+ updateFrameBudget: async () => {}
}
}
@@ -257,23 +256,6 @@ describe('screencast ownership', () => {
await second.session.done
})
- it('settles dialogs through the stream owned by the command instance', async () => {
- const session = createSession()
- const settleDialog = vi.spyOn(session, 'settleDialog').mockResolvedValue(true)
- startBrowserScreencast.mockResolvedValue(session)
- const commands = new RuntimeBrowserCommands(createSinglePageBrowserCommandsHost())
- const stream = await commands.browserScreencast(params, { sendBinary: () => true })
-
- expect(await commands.browserDialogAccept({ page: params.page, text: 'Ada' })).toEqual({
- accepted: true
- })
- expect(settleDialog).toHaveBeenCalledWith(true, 'Ada')
- expect(await commands.browserDialogDismiss({ page: params.page })).toEqual({ accepted: false })
- expect(settleDialog).toHaveBeenLastCalledWith(false, undefined)
- stream.session.stop()
- await stream.session.done
- })
-
it('accepts startup callbacks before the stream promise is returned', async () => {
const session = createSession()
const startupFrame = new Uint8Array([4, 5, 6])
diff --git a/src/main/runtime/browser/browser-screencasts.ts b/src/main/runtime/browser/browser-screencasts.ts
index 9e7fd77506e..cdefc42b053 100644
--- a/src/main/runtime/browser/browser-screencasts.ts
+++ b/src/main/runtime/browser/browser-screencasts.ts
@@ -1,4 +1,3 @@
-import { settleBrowserDialogOnLiveScreencast } from '../browser-dialog-settlement'
import type { BrowserScreencastResult } from '../../../shared/runtime-types'
import { BrowserError } from '../../browser/browser-error'
import { randomUUID } from 'node:crypto'
@@ -257,17 +256,4 @@ export class RuntimeBrowserScreencasts {
// Departed viewers must not pin the shared frame budget.
void applySharedScreencastFrameBudget(active, session).catch(() => {})
}
-
- settleDialog(
- browserPageId: string | undefined,
- accept: boolean,
- promptText?: string
- ): Promise<boolean> {
- return settleBrowserDialogOnLiveScreencast(
- this.activeScreencastsByPageId,
- browserPageId,
- accept,
- promptText
- )
- }
}
diff --git a/src/main/window/createMainWindow.test.ts b/src/main/window/createMainWindow.test.ts
index fc89d63b7bb..196a3e0acb9 100644
--- a/src/main/window/createMainWindow.test.ts
+++ b/src/main/window/createMainWindow.test.ts
@@ -18,6 +18,9 @@ vi.mock('../browser/browser-route-session-runtime', async () => ({
attachGuest: (await import('./createMainWindow-test-harness')).attachRouteGuestMock
}
}))
+vi.mock('../browser/browser-javascript-dialogs', () => ({
+ installBrowserJavaScriptDialogs: vi.fn()
+}))
vi.mock('../browser/browser-client-page-renderer-runtime', async () => {
const harness = await import('./createMainWindow-test-harness')
return {
diff --git a/src/main/window/main-window-webview-security.test.ts b/src/main/window/main-window-webview-security.test.ts
index df9b030f4ab..fd5d28ad702 100644
--- a/src/main/window/main-window-webview-security.test.ts
+++ b/src/main/window/main-window-webview-security.test.ts
@@ -6,6 +6,7 @@ const mocks = vi.hoisted(() => ({
installNavigationPolicy: vi.fn(),
isAllowedPartition: vi.fn(),
attachRouteGuest: vi.fn(),
+ installJavaScriptDialogs: vi.fn(),
registerPluginGuard: vi.fn()
}))
@@ -32,6 +33,9 @@ vi.mock('../browser/local-ssh-browser-partitions', () => ({
vi.mock('../browser/extensions/browser-extension-session-loader', () => ({
getBrowserExtensionSessionForProfile: () => null
}))
+vi.mock('../browser/browser-javascript-dialogs', () => ({
+ installBrowserJavaScriptDialogs: mocks.installJavaScriptDialogs
+}))
vi.mock('../browser/doc-preview-protocol', () => ({
isDocPreviewSession: (candidate: unknown) => candidate === 'doc-preview-session'
}))
@@ -272,6 +276,7 @@ describe('orca-preview scheme admission', () => {
}
)
expect(mocks.attachRouteGuest).not.toHaveBeenCalled()
+ expect(mocks.installJavaScriptDialogs).not.toHaveBeenCalled()
})
it('keeps browser guests on the browsing profile and its route registration', () => {
@@ -282,6 +287,7 @@ describe('orca-preview scheme admission', () => {
expect(mocks.attachGuestPolicies).toHaveBeenCalledOnce()
expect(mocks.attachGuestPolicies.mock.calls[0]?.[2]).toBeUndefined()
expect(mocks.attachRouteGuest).toHaveBeenCalledOnce()
+ expect(mocks.installJavaScriptDialogs).toHaveBeenCalledOnce()
})
// WebContents teardown leaves no preview readers; clear grants and the dead failure sink.
diff --git a/src/main/window/main-window-webview-security.ts b/src/main/window/main-window-webview-security.ts
index 795432fcf41..691833885df 100644
--- a/src/main/window/main-window-webview-security.ts
+++ b/src/main/window/main-window-webview-security.ts
@@ -24,6 +24,7 @@ import { registerHostFrameNavigationGuard } from './host-frame-navigation-guard'
import { installPrivilegedWindowNavigationPolicy } from './privileged-window-navigation'
import { parseChromeExtensionUrl } from '../../shared/browser-extension-url'
import { getBrowserExtensionSessionForProfile } from '../browser/extensions/browser-extension-session-loader'
+import { installBrowserJavaScriptDialogs } from '../browser/browser-javascript-dialogs'
/** orca-preview is outside normal browser URL admission; require the doc partition and a main-minted user-preview grant. */
function isAdmissibleDocPreviewAttach(partition: string, src: string): boolean {
@@ -133,6 +134,7 @@ export function installMainWindowWebviewSecurity(mainWindow: BrowserWindow): voi
}
// Install popup/navigation policy at creation or early redirects/target=_blank can outrun registration.
browserManager.attachGuestPolicies(guest)
+ installBrowserJavaScriptDialogs(guest, () => browserManager.resolvePagePromptTarget(guest))
// Route guests stay blank until exact main-owned registration and override generic popup routing.
browserRouteWebContentsRegistry.attachGuest(guest)
// Proxies cannot block WebRTC UDP; enforce it per WebContents.
diff --git a/src/preload/browser-window-close.ts b/src/preload/browser-window-close.ts
index 3d1a0117b08..05d2dc41c07 100644
--- a/src/preload/browser-window-close.ts
+++ b/src/preload/browser-window-close.ts
@@ -2,6 +2,7 @@ import {
installBrowserWindowCloseGuard,
PRELOAD_BROWSER_GUEST_WINDOW_CLOSE_CHANNEL
} from './browser-window-close-installation'
+import { installBrowserWindowPrompt } from './browser-window-prompt-installation'
import type { ContextBridge, IpcRenderer } from 'electron'
// Raw require keeps the sandboxed preload standalone in the CJS build.
@@ -18,3 +19,5 @@ if (process.isMainFrame) {
args: [() => ipcRenderer.sendToHost(PRELOAD_BROWSER_GUEST_WINDOW_CLOSE_CHANNEL)]
})
}
+// Every frame this preload runs in also got Electron's throwing prompt.
+contextBridge.executeInMainWorld({ func: installBrowserWindowPrompt, args: [] })
diff --git a/src/preload/browser-window-prompt-installation.ts b/src/preload/browser-window-prompt-installation.ts
new file mode 100644
index 00000000000..fa9ade1e149
--- /dev/null
+++ b/src/preload/browser-window-prompt-installation.ts
@@ -0,0 +1,23 @@
+/**
+ * Runs serialized in the page's main world. Electron replaces `window.prompt` with one that throws;
+ * an about:blank child frame keeps Chromium's, so the prompt reaches Orca like alert and confirm do.
+ */
+export function installBrowserWindowPrompt(): void {
+ const prompt = (message?: string, defaultValue?: string): string | null => {
+ // The HTML namespace keeps this an iframe in SVG and other XML documents too.
+ const frame = document.createElementNS('http://www.w3.org/1999/xhtml', 'iframe')
+ if (!(frame instanceof HTMLIFrameElement)) {
+ return null
+ }
+ frame.style.display = 'none'
+ document.documentElement.append(frame)
+ try {
+ return frame.contentWindow?.prompt(message, defaultValue) ?? null
+ } finally {
+ frame.remove()
+ }
+ }
+ try {
+ window.prompt = prompt
+ } catch {}
+}
diff --git a/src/renderer/src/components/browser-pane/browser-javascript-dialog-prompt.ts b/src/renderer/src/components/browser-pane/browser-javascript-dialog-prompt.ts
new file mode 100644
index 00000000000..28c1ab84acf
--- /dev/null
+++ b/src/renderer/src/components/browser-pane/browser-javascript-dialog-prompt.ts
@@ -0,0 +1,46 @@
+import type { BrowserPagePromptHandler } from './browser-page-prompts'
+import { translate } from '@/i18n/i18n'
+
+export const javaScriptDialogPrompt: BrowserPagePromptHandler<'javascript-dialog'> = {
+ ask: async (confirm, { type, message, defaultPromptText, origin }, signal) => {
+ let promptText = ''
+ const accept = await confirm({
+ signal,
+ title: origin
+ ? translate('auto.components.browserPane.javaScriptDialog.title', '{{origin}} says', {
+ origin
+ })
+ : translate(
+ 'auto.components.browserPane.javaScriptDialog.anonymousTitle',
+ 'This page says'
+ ),
+ description: message,
+ // Page text has no length limit; keep the buttons on screen.
+ descriptionClassName: 'max-h-[50vh] overflow-y-auto whitespace-pre-wrap break-words',
+ acknowledgeOnly: type === 'alert',
+ // Enter accepts, as in Chrome; a prompt keeps focus in its answer field.
+ initialFocus: type === 'prompt' ? undefined : 'confirm',
+ // A held Enter on the page's own button must not also answer the dialog it opened.
+ ignoresOpeningGesture: true,
+ confirmLabel: translate('auto.components.browserPane.javaScriptDialog.confirm', 'OK'),
+ cancelLabel: translate('auto.components.browserPane.javaScriptDialog.cancel', 'Cancel'),
+ fields:
+ type === 'prompt'
+ ? {
+ inputs: [
+ {
+ id: 'promptText',
+ label: translate('auto.components.browserPane.javaScriptDialog.answer', 'Answer'),
+ defaultValue: defaultPromptText
+ }
+ ],
+ onConfirmed: (values) => {
+ promptText = values.promptText ?? ''
+ }
+ }
+ : undefined
+ })
+ // Every close is an answer the page waits for; null would also quiet the page's other prompts.
+ return { accept, promptText }
+ }
+}
diff --git a/src/renderer/src/components/browser-pane/browser-page-prompts.tsx b/src/renderer/src/components/browser-pane/browser-page-prompts.tsx
index f5be88c84e9..7cf27064670 100644
--- a/src/renderer/src/components/browser-pane/browser-page-prompts.tsx
+++ b/src/renderer/src/components/browser-pane/browser-page-prompts.tsx
@@ -11,6 +11,7 @@ import {
} from '@/components/confirmation-dialog-context'
import { externalAppPrompt } from './browser-external-app-prompt'
import { httpAuthPrompt } from './browser-http-auth-prompt'
+import { javaScriptDialogPrompt } from './browser-javascript-dialog-prompt'
import { sitePermissionPrompt } from './browser-site-permission-prompt'
/** How the window asks one kind of page prompt. */
@@ -28,6 +29,7 @@ export type BrowserPagePromptHandler<K extends BrowserPagePromptKind> = {
const PROMPT_HANDLERS: { [K in BrowserPagePromptKind]: BrowserPagePromptHandler<K> } = {
'external-app': externalAppPrompt,
'http-auth': httpAuthPrompt,
+ 'javascript-dialog': javaScriptDialogPrompt,
'site-permission': sitePermissionPrompt
}
diff --git a/src/renderer/src/components/confirmation-dialog-context.ts b/src/renderer/src/components/confirmation-dialog-context.ts
index b6bd3446157..65376347d3f 100644
--- a/src/renderer/src/components/confirmation-dialog-context.ts
+++ b/src/renderer/src/components/confirmation-dialog-context.ts
@@ -8,6 +8,7 @@ export type ConfirmationDialogField = {
label: string
type?: 'text' | 'password'
autoComplete?: string
+ defaultValue?: string
}
export type ConfirmationDialogOptions = {
diff --git a/src/renderer/src/components/confirmation-dialog.tsx b/src/renderer/src/components/confirmation-dialog.tsx
index 4a92e403588..b0ae7a4428c 100644
--- a/src/renderer/src/components/confirmation-dialog.tsx
+++ b/src/renderer/src/components/confirmation-dialog.tsx
@@ -108,8 +108,12 @@ export function ConfirmationDialogProvider({
if (confirmed && dontAskAgain) {
request.options.dontAskAgain?.onConfirmed()
}
- if (confirmed) {
- request.options.fields?.onConfirmed(fieldValues)
+ const fields = request.options.fields
+ if (confirmed && fields) {
+ const defaults = Object.fromEntries(
+ fields.inputs.map((field) => [field.id, field.defaultValue ?? ''])
+ )
+ fields.onConfirmed({ ...defaults, ...fieldValues })
}
// Why: queued prompts must not inherit this request's preference or typed values.
setDontAskAgain(false)
@@ -182,7 +186,7 @@ export function ConfirmationDialogProvider({
id={`confirmation-dialog-field-${field.id}`}
type={field.type ?? 'text'}
autoComplete={field.autoComplete}
- value={fieldValues[field.id] ?? ''}
+ value={fieldValues[field.id] ?? field.defaultValue ?? ''}
onChange={(event) => {
const { value } = event.target
setFieldValues((current) => ({ ...current, [field.id]: value }))
@@ -190,7 +194,9 @@ export function ConfirmationDialogProvider({
onKeyDown={(event) => {
if (event.key === 'Enter') {
event.preventDefault()
- settleActiveRequest(true)
+ if (!(guarded && event.repeat)) {
+ settleActiveRequest(true)
+ }
}
}}
/>
diff --git a/src/renderer/src/i18n/locales/de.json b/src/renderer/src/i18n/locales/de.json
index 50ba5144614..3c9c0335fa1 100644
--- a/src/renderer/src/i18n/locales/de.json
+++ b/src/renderer/src/i18n/locales/de.json
@@ -18398,6 +18398,13 @@
"confirm": "Anmelden",
"cancel": "Abbrechen"
},
+ "javaScriptDialog": {
+ "title": "{{origin}} meldet",
+ "anonymousTitle": "Diese Seite meldet",
+ "confirm": "OK",
+ "cancel": "Abbrechen",
+ "answer": "Antwort"
+ },
"sitePermission": {
"label": {
"camera": "Kamera",
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index a4601906140..2bf7a8b6af1 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -18691,6 +18691,13 @@
"confirm": "Sign in",
"cancel": "Cancel"
},
+ "javaScriptDialog": {
+ "title": "{{origin}} says",
+ "anonymousTitle": "This page says",
+ "confirm": "OK",
+ "cancel": "Cancel",
+ "answer": "Answer"
+ },
"sitePermission": {
"label": {
"camera": "Camera",
diff --git a/src/renderer/src/i18n/locales/es.json b/src/renderer/src/i18n/locales/es.json
index 8971d0562b5..9e8f24ba39c 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -18374,6 +18374,13 @@
"insecure": "Su conexión a este sitio no es privada.",
"description": "{{origin}} solicita un nombre de usuario y contraseña."
},
+ "javaScriptDialog": {
+ "title": "{{origin}} dice",
+ "anonymousTitle": "Esta página dice",
+ "confirm": "Aceptar",
+ "cancel": "Cancelar",
+ "answer": "Respuesta"
+ },
"sitePermission": {
"label": {
"camera": "Cámara",
diff --git a/src/renderer/src/i18n/locales/fr.json b/src/renderer/src/i18n/locales/fr.json
index ec0cee6146a..e66ed299316 100644
--- a/src/renderer/src/i18n/locales/fr.json
+++ b/src/renderer/src/i18n/locales/fr.json
@@ -18598,6 +18598,13 @@
"retry": "Ce nom d'utilisateur ou ce mot de passe n'a pas fonctionné.",
"description": "{{origin}} demande un nom d'utilisateur et un mot de passe."
},
+ "javaScriptDialog": {
+ "title": "{{origin}} indique",
+ "anonymousTitle": "Cette page indique",
+ "confirm": "OK",
+ "cancel": "Annuler",
+ "answer": "Réponse"
+ },
"sitePermission": {
"label": {
"camera": "Caméra",
diff --git a/src/renderer/src/i18n/locales/ja.json b/src/renderer/src/i18n/locales/ja.json
index dccc4ed7028..79b2ae0df71 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -17903,6 +17903,13 @@
"description": "{{origin}} はユーザー名とパスワードを要求しています。",
"retry": "ユーザー名またはパスワードが正しくありません。"
},
+ "javaScriptDialog": {
+ "title": "{{origin}} の内容",
+ "anonymousTitle": "このページの内容",
+ "confirm": "OK",
+ "cancel": "キャンセル",
+ "answer": "回答"
+ },
"sitePermission": {
"label": {
"camera": "カメラ",
diff --git a/src/renderer/src/i18n/locales/ko.json b/src/renderer/src/i18n/locales/ko.json
index ba1805447d9..b0c8e51ec2c 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -17903,6 +17903,13 @@
"password": "비밀번호",
"retry": "사용자 이름 또는 비밀번호가 올바르지 않습니다."
},
+ "javaScriptDialog": {
+ "title": "{{origin}} 내용:",
+ "anonymousTitle": "이 페이지 내용:",
+ "confirm": "확인",
+ "cancel": "취소",
+ "answer": "답변"
+ },
"sitePermission": {
"label": {
"camera": "카메라",
diff --git a/src/renderer/src/i18n/locales/pt.json b/src/renderer/src/i18n/locales/pt.json
index f5ea8c07a0b..bfc6e3e25f8 100644
--- a/src/renderer/src/i18n/locales/pt.json
+++ b/src/renderer/src/i18n/locales/pt.json
@@ -19441,6 +19441,13 @@
"confirm": "Entrar",
"cancel": "Cancelar"
},
+ "javaScriptDialog": {
+ "title": "{{origin}} diz",
+ "anonymousTitle": "Esta página diz",
+ "confirm": "OK",
+ "cancel": "Cancelar",
+ "answer": "Resposta"
+ },
"sitePermission": {
"label": {
"camera": "Câmera",
diff --git a/src/renderer/src/i18n/locales/ru.json b/src/renderer/src/i18n/locales/ru.json
index d610fd55d9d..ac49f108bdc 100644
--- a/src/renderer/src/i18n/locales/ru.json
+++ b/src/renderer/src/i18n/locales/ru.json
@@ -18956,6 +18956,13 @@
"confirm": "Войти",
"cancel": "Отмена"
},
+ "javaScriptDialog": {
+ "title": "{{origin}} сообщает",
+ "anonymousTitle": "Эта страница сообщает",
+ "confirm": "ОК",
+ "cancel": "Отмена",
+ "answer": "Ответ"
+ },
"sitePermission": {
"label": {
"camera": "Камера",
diff --git a/src/renderer/src/i18n/locales/tr.json b/src/renderer/src/i18n/locales/tr.json
index 2da292700b5..5cd5ff4c56a 100644
--- a/src/renderer/src/i18n/locales/tr.json
+++ b/src/renderer/src/i18n/locales/tr.json
@@ -18384,6 +18384,13 @@
"confirm": "Oturum aç",
"cancel": "İptal"
},
+ "javaScriptDialog": {
+ "title": "{{origin}} diyor ki",
+ "anonymousTitle": "Bu sayfa diyor ki",
+ "confirm": "Tamam",
+ "cancel": "İptal",
+ "answer": "Yanıt"
+ },
"sitePermission": {
"label": {
"camera": "Kamera",
diff --git a/src/renderer/src/i18n/locales/zh-Hant.json b/src/renderer/src/i18n/locales/zh-Hant.json
index 71e6a1ec66f..5582ef78eb5 100644
--- a/src/renderer/src/i18n/locales/zh-Hant.json
+++ b/src/renderer/src/i18n/locales/zh-Hant.json
@@ -18145,6 +18145,13 @@
"confirm": "登入",
"cancel": "取消"
},
+ "javaScriptDialog": {
+ "title": "{{origin}} 顯示",
+ "anonymousTitle": "此網頁顯示",
+ "confirm": "確定",
+ "cancel": "取消",
+ "answer": "回答"
+ },
"sitePermission": {
"label": {
"camera": "攝影機",
diff --git a/src/renderer/src/i18n/locales/zh.json b/src/renderer/src/i18n/locales/zh.json
index 31be9741eb4..90aeac606db 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -17903,6 +17903,13 @@
"retry": "该用户名或密码无效。",
"description": "{{origin}} 要求输入用户名和密码。"
},
+ "javaScriptDialog": {
+ "title": "{{origin}} 显示",
+ "anonymousTitle": "此网页显示",
+ "confirm": "确定",
+ "cancel": "取消",
+ "answer": "回答"
+ },
"sitePermission": {
"label": {
"camera": "摄像头",
diff --git a/src/shared/browser-javascript-dialog.ts b/src/shared/browser-javascript-dialog.ts
new file mode 100644
index 00000000000..2fa131f6e57
--- /dev/null
+++ b/src/shared/browser-javascript-dialog.ts
@@ -0,0 +1,18 @@
+/** A page's open `alert()`, `confirm()` or `prompt()` in the built-in browser. */
+export type BrowserJavaScriptDialog = {
+ type: 'alert' | 'confirm' | 'prompt'
+ message: string
+ /** The text a prompt starts with; empty for alert and confirm. */
+ defaultPromptText: string
+}
+
+export type BrowserJavaScriptDialogPrompt = BrowserJavaScriptDialog & {
+ /** Origin of the page that opened it; null when it has none, e.g. `about:blank`. */
+ origin: string | null
+}
+
+export type BrowserJavaScriptDialogAnswer = {
+ accept: boolean
+ /** What a prompt returns when accepted. */
+ promptText: string
+}
diff --git a/src/shared/browser-page-prompt.ts b/src/shared/browser-page-prompt.ts
index 969157ee2ed..a4c63622924 100644
--- a/src/shared/browser-page-prompt.ts
+++ b/src/shared/browser-page-prompt.ts
@@ -1,5 +1,9 @@
import type { BrowserExternalAppPrompt } from './browser-external-app'
import type { BrowserHttpAuthCredentials, BrowserHttpAuthPrompt } from './browser-http-auth'
+import type {
+ BrowserJavaScriptDialogAnswer,
+ BrowserJavaScriptDialogPrompt
+} from './browser-javascript-dialog'
import type {
BrowserSitePermissionDecision,
BrowserSitePermissionPrompt
@@ -9,6 +13,10 @@ import type {
export type BrowserPagePromptKinds = {
'external-app': { details: BrowserExternalAppPrompt; answer: true }
'http-auth': { details: BrowserHttpAuthPrompt; answer: BrowserHttpAuthCredentials }
+ 'javascript-dialog': {
+ details: BrowserJavaScriptDialogPrompt
+ answer: BrowserJavaScriptDialogAnswer
+ }
'site-permission': { details: BrowserSitePermissionPrompt; answer: BrowserSitePermissionDecision }
}