brave-real-puppeteer-core 24.26.1 → 24.33.0

package/src/bidi/core/BrowsingContext.ts

@@ -6,9 +6,15 @@
 
 import type * as Bidi from 'webdriver-bidi-protocol';
 
+import type {BluetoothEmulation} from '../../api/BluetoothEmulation.js';
+import type {DeviceRequestPrompt} from '../../api/DeviceRequestPrompt.js';
 import {EventEmitter} from '../../common/EventEmitter.js';
+import {isString} from '../../common/util.js';
+import {assert} from '../../util/assert.js';
 import {inertIfDisposed, throwIfDisposed} from '../../util/decorators.js';
 import {DisposableStack, disposeSymbol} from '../../util/disposable.js';
+import {BidiBluetoothEmulation} from '../BluetoothEmulation.js';
+import {BidiDeviceRequestPromptManager} from '../DeviceRequestPrompt.js';
 
 import type {AddPreloadScriptOptions} from './Browser.js';
 import {Navigation} from './Navigation.js';
@@ -161,9 +167,11 @@ export class BrowsingContext extends EventEmitter<{
   readonly #emulationState: {
     javaScriptEnabled: boolean;
   } = {javaScriptEnabled: true};
+  readonly #bluetoothEmulation: BluetoothEmulation;
+  readonly #deviceRequestPromptManager: BidiDeviceRequestPromptManager;
 
   private constructor(
-    context: UserContext,
+    userContext: UserContext,
     parent: BrowsingContext | undefined,
     id: string,
     url: string,
@@ -174,10 +182,18 @@ export class BrowsingContext extends EventEmitter<{
     this.#url = url;
     this.id = id;
     this.parent = parent;
-    this.userContext = context;
+    this.userContext = userContext;
     this.originalOpener = originalOpener;
 
     this.defaultRealm = this.#createWindowRealm();
+    this.#bluetoothEmulation = new BidiBluetoothEmulation(
+      this.id,
+      this.#session,
+    );
+    this.#deviceRequestPromptManager = new BidiDeviceRequestPromptManager(
+      this.id,
+      this.#session,
+    );
   }
 
   #initialize() {
@@ -601,6 +617,19 @@ export class BrowsingContext extends EventEmitter<{
     );
   }
 
+  @throwIfDisposed<BrowsingContext>(context => {
+    // SAFETY: Disposal implies this exists.
+    return context.#reason!;
+  })
+  async setScreenOrientationOverride(
+    screenOrientation: Bidi.Emulation.ScreenOrientation | null,
+  ): Promise<void> {
+    await this.#session.send('emulation.setScreenOrientationOverride', {
+      screenOrientation,
+      contexts: [this.id],
+    });
+  }
+
   @throwIfDisposed<BrowsingContext>(context => {
     // SAFETY: Disposal implies this exists.
     return context.#reason!;
@@ -726,4 +755,53 @@ export class BrowsingContext extends EventEmitter<{
   isJavaScriptEnabled(): boolean {
     return this.#emulationState.javaScriptEnabled;
   }
+
+  async setUserAgent(userAgent: string | null): Promise<void> {
+    await this.#session.send('emulation.setUserAgentOverride', {
+      userAgent,
+      contexts: [this.id],
+    });
+  }
+
+  async setOfflineMode(enabled: boolean): Promise<void> {
+    await this.#session.send('emulation.setNetworkConditions', {
+      networkConditions: enabled
+        ? {
+            type: 'offline',
+          }
+        : null,
+      contexts: [this.id],
+    });
+  }
+
+  get bluetooth(): BluetoothEmulation {
+    return this.#bluetoothEmulation;
+  }
+
+  async waitForDevicePrompt(
+    timeout: number,
+    signal?: AbortSignal,
+  ): Promise<DeviceRequestPrompt> {
+    return await this.#deviceRequestPromptManager.waitForDevicePrompt(
+      timeout,
+      signal,
+    );
+  }
+
+  async setExtraHTTPHeaders(headers: Record<string, string>): Promise<void> {
+    await this.#session.send('network.setExtraHeaders', {
+      headers: Object.entries(headers).map(([key, value]) => {
+        assert(
+          isString(value),
+          `Expected value of header "${key}" to be String, but "${typeof value}" is found.`,
+        );
+
+        return {
+          name: key.toLowerCase(),
+          value: {type: 'string', value: value},
+        };
+      }),
+      contexts: [this.id],
+    });
+  }
 }

package/src/bidi/core/Connection.ts

@@ -21,8 +21,9 @@ export type BidiEvents = {
 /**
  * @internal
  */
-export interface Connection<Events extends BidiEvents = BidiEvents>
-  extends EventEmitter<Events> {
+export interface Connection<
+  Events extends BidiEvents = BidiEvents,
+> extends EventEmitter<Events> {
   send<T extends keyof Commands>(
     method: T,
     params: Commands[T]['params'],

package/src/bidi/util.ts

@@ -17,6 +17,14 @@ import {BidiDeserializer} from './Deserializer.js';
 export function createEvaluationError(
   details: Bidi.Script.ExceptionDetails,
 ): unknown {
+  if (details.exception.type === 'object' && !('value' in details.exception)) {
+    // Heuristic detecting a platform object was thrown. WebDriver BiDi serializes
+    // platform objects without value. If so, throw a generic error with the actual
+    // exception's message, as there is no way to restore the original exception's
+    // constructor.
+    return new Error(details.text);
+  }
+
   if (details.exception.type !== 'error') {
     return BidiDeserializer.deserialize(details.exception);
   }

package/src/cdp/Accessibility.ts

@@ -8,6 +8,7 @@ import type {Protocol} from 'devtools-protocol';
 
 import type {ElementHandle} from '../api/ElementHandle.js';
 import type {Realm} from '../api/Realm.js';
+import {debugError} from '../common/util.js';
 
 /**
  * Represents a Node and the properties of it that are relevant to Accessibility.
@@ -86,6 +87,13 @@ export interface SerializedAXNode {
    */
   children?: SerializedAXNode[];
 
+  /**
+   * CDP-specifc ID to reference the DOM node.
+   *
+   * @internal
+   */
+  backendNodeId?: number;
+
   /**
    * Get an ElementHandle for this AXNode if available.
    *
@@ -231,8 +239,13 @@ export class Accessibility {
         if (!frame) {
           return;
         }
-        const iframeSnapshot = await frame.accessibility.snapshot(options);
-        root.iframeSnapshot = iframeSnapshot ?? undefined;
+        try {
+          const iframeSnapshot = await frame.accessibility.snapshot(options);
+          root.iframeSnapshot = iframeSnapshot ?? undefined;
+        } catch (error) {
+          // Frames can get detached at any time resulting in errors.
+          debugError(error);
+        }
       }
       for (const child of root.children) {
         await populateIframes(child);
@@ -539,6 +552,7 @@ class AXNode {
           return node.nodeType === Node.TEXT_NODE ? node.parentElement : node;
         })) as ElementHandle<Element>;
       },
+      backendNodeId: this.payload.backendDOMNodeId,
     };
 
     type UserStringProperty =
@@ -604,7 +618,7 @@ class AXNode {
         continue;
       }
       const value = getBooleanPropertyValue(booleanProperty);
-      if (!value) {
+      if (value === undefined) {
         continue;
       }
       node[booleanProperty] = getBooleanPropertyValue(booleanProperty);

package/src/cdp/BluetoothEmulation.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2025 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type {
+  AdapterState,
+  BluetoothEmulation,
+  PreconnectedPeripheral,
+} from '../api/BluetoothEmulation.js';
+
+import type {Connection} from './Connection.js';
+
+/**
+ * @internal
+ */
+export class CdpBluetoothEmulation implements BluetoothEmulation {
+  #connection: Connection;
+
+  constructor(connection: Connection) {
+    this.#connection = connection;
+  }
+
+  async emulateAdapter(state: AdapterState, leSupported = true): Promise<void> {
+    // Bluetooth spec requires overriding the existing adapter (step 6). From the CDP
+    // perspective, it means disabling the emulation first.
+    // https://webbluetoothcg.github.io/web-bluetooth/#bluetooth-simulateAdapter-command
+    await this.#connection.send('BluetoothEmulation.disable');
+    await this.#connection.send('BluetoothEmulation.enable', {
+      state,
+      leSupported,
+    });
+  }
+
+  async disableEmulation(): Promise<void> {
+    await this.#connection.send('BluetoothEmulation.disable');
+  }
+
+  async simulatePreconnectedPeripheral(
+    preconnectedPeripheral: PreconnectedPeripheral,
+  ): Promise<void> {
+    await this.#connection.send(
+      'BluetoothEmulation.simulatePreconnectedPeripheral',
+      preconnectedPeripheral,
+    );
+  }
+}

package/src/cdp/Browser.ts

@@ -8,7 +8,7 @@ import type {ChildProcess} from 'node:child_process';
 
 import type {Protocol} from 'devtools-protocol';
 
-import type {DebugInfo} from '../api/Browser.js';
+import type {CreatePageOptions, DebugInfo} from '../api/Browser.js';
 import {
   Browser as BrowserBase,
   BrowserEvent,
@@ -16,6 +16,10 @@ import {
   type BrowserContextOptions,
   type IsPageTargetCallback,
   type TargetFilterCallback,
+  type ScreenInfo,
+  type AddScreenParams,
+  type WindowBounds,
+  type WindowId,
 } from '../api/Browser.js';
 import {BrowserContextEvent} from '../api/BrowserContext.js';
 import {CDPSessionEvent} from '../api/CDPSession.js';
@@ -196,7 +200,9 @@ export class CdpBrowser extends BrowserBase {
           target.type() === 'webview' ||
           (this.#handleDevToolsAsPage &&
             target.type() === 'other' &&
-            target.url().startsWith('devtools://'))
+            target
+              .url()
+              .startsWith('devtools://devtools/bundled/devtools_app.html'))
         );
       });
   }
@@ -343,19 +349,30 @@ export class CdpBrowser extends BrowserBase {
     return this.#connection.url();
   }
 
-  override async newPage(): Promise<Page> {
-    return await this.#defaultContext.newPage();
+  override async newPage(options?: CreatePageOptions): Promise<Page> {
+    return await this.#defaultContext.newPage(options);
   }
 
-  // rebrowser-patches: expose browser CDP session
-  _connection(): Connection {
-    return this.#connection;
-  }
-
-  async _createPageInContext(contextId?: string): Promise<Page> {
+  async _createPageInContext(
+    contextId?: string,
+    options?: CreatePageOptions,
+  ): Promise<Page> {
+    const hasTargets =
+      this.targets().filter(t => {
+        return t.browserContext().id === contextId;
+      }).length > 0;
+    const windowBounds =
+      options?.type === 'window' ? options.windowBounds : undefined;
     const {targetId} = await this.#connection.send('Target.createTarget', {
       url: 'about:blank',
       browserContextId: contextId || undefined,
+      left: windowBounds?.left,
+      top: windowBounds?.top,
+      width: windowBounds?.width,
+      height: windowBounds?.height,
+      windowState: windowBounds?.windowState,
+      // Works around crbug.com/454825274.
+      newWindow: hasTargets && options?.type === 'window' ? true : undefined,
     });
     const target = (await this.waitForTarget(t => {
       return (t as CdpTarget)._targetId === targetId;
@@ -378,6 +395,38 @@ export class CdpBrowser extends BrowserBase {
     return page;
   }
 
+  async _createDevToolsPage(pageTargetId: string): Promise<Page> {
+    const openDevToolsResponse = await this.#connection.send(
+      'Target.openDevTools',
+      {
+        targetId: pageTargetId,
+      },
+    );
+    const target = (await this.waitForTarget(t => {
+      return (t as CdpTarget)._targetId === openDevToolsResponse.targetId;
+    })) as CdpTarget;
+    if (!target) {
+      throw new Error(
+        `Missing target for DevTools page (id = ${pageTargetId})`,
+      );
+    }
+    const initialized =
+      (await target._initializedDeferred.valueOrThrow()) ===
+      InitializationStatus.SUCCESS;
+    if (!initialized) {
+      throw new Error(
+        `Failed to create target for DevTools page (id = ${pageTargetId})`,
+      );
+    }
+    const page = await target.page();
+    if (!page) {
+      throw new Error(
+        `Failed to create a DevTools Page for target (id = ${pageTargetId})`,
+      );
+    }
+    return page;
+  }
+
   override async installExtension(path: string): Promise<string> {
     const {id} = await this.#connection.send('Extensions.loadUnpacked', {path});
     return id;
@@ -387,6 +436,42 @@ export class CdpBrowser extends BrowserBase {
     return this.#connection.send('Extensions.uninstall', {id});
   }
 
+  override async screens(): Promise<ScreenInfo[]> {
+    const {screenInfos} = await this.#connection.send(
+      'Emulation.getScreenInfos',
+    );
+    return screenInfos;
+  }
+
+  override async addScreen(params: AddScreenParams): Promise<ScreenInfo> {
+    const {screenInfo} = await this.#connection.send(
+      'Emulation.addScreen',
+      params,
+    );
+    return screenInfo;
+  }
+
+  override async removeScreen(screenId: string): Promise<void> {
+    return await this.#connection.send('Emulation.removeScreen', {screenId});
+  }
+
+  override async getWindowBounds(windowId: WindowId): Promise<WindowBounds> {
+    const {bounds} = await this.#connection.send('Browser.getWindowBounds', {
+      windowId: Number(windowId),
+    });
+    return bounds;
+  }
+
+  override async setWindowBounds(
+    windowId: WindowId,
+    windowBounds: WindowBounds,
+  ): Promise<void> {
+    await this.#connection.send('Browser.setWindowBounds', {
+      windowId: Number(windowId),
+      bounds: windowBounds,
+    });
+  }
+
   override targets(): CdpTarget[] {
     return Array.from(
       this.#targetManager.getAvailableTargets().values(),

package/src/cdp/BrowserConnector.ts

@@ -7,6 +7,7 @@
 import type {ConnectionTransport} from '../common/ConnectionTransport.js';
 import type {ConnectOptions} from '../common/ConnectOptions.js';
 import {debugError, DEFAULT_VIEWPORT} from '../common/util.js';
+import {createIncrementalIdGenerator} from '../util/incremental-id-generator.js';
 
 import {CdpBrowser} from './Browser.js';
 import {Connection} from './Connection.js';
@@ -32,6 +33,7 @@ export async function _connectToCdpBrowser(
     slowMo = 0,
     protocolTimeout,
     handleDevToolsAsPage,
+    idGenerator = createIncrementalIdGenerator(),
   } = options;
 
   const connection = new Connection(
@@ -39,6 +41,8 @@ export async function _connectToCdpBrowser(
     connectionTransport,
     slowMo,
     protocolTimeout,
+    /* rawErrors */ false,
+    idGenerator,
   );
 
   const {browserContextIds} = await connection.send(

package/src/cdp/BrowserContext.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type {CreatePageOptions} from '../api/Browser.js';
 import {
   WEB_PERMISSION_TO_PROTOCOL_PERMISSION,
   type Permission,
@@ -44,13 +45,13 @@ export class CdpBrowserContext extends BrowserContext {
     });
   }
 
-  override async pages(): Promise<Page[]> {
+  override async pages(includeAll = false): Promise<Page[]> {
     const pages = await Promise.all(
       this.targets()
         .filter(target => {
           return (
             target.type() === 'page' ||
-            (target.type() === 'other' &&
+            ((target.type() === 'other' || includeAll) &&
               this.#browser._getIsPageTargetCallback()?.(target))
           );
         })
@@ -88,9 +89,9 @@ export class CdpBrowserContext extends BrowserContext {
     });
   }
 
-  override async newPage(): Promise<Page> {
+  override async newPage(options?: CreatePageOptions): Promise<Page> {
     using _guard = await this.waitForScreenshotOperations();
-    return await this.#browser._createPageInContext(this.#id);
+    return await this.#browser._createPageInContext(this.#id, options);
   }
 
   override browser(): CdpBrowser {

package/src/cdp/CdpSession.ts

@@ -27,7 +27,7 @@ import type {CdpTarget} from './Target.js';
 export class CdpCDPSession extends CDPSession {
   #sessionId: string;
   #targetType: string;
-  #callbacks = new CallbackRegistry();
+  #callbacks: CallbackRegistry;
   #connection: Connection;
   #parentSessionId?: string;
   #target?: CdpTarget;
@@ -46,6 +46,7 @@ export class CdpCDPSession extends CDPSession {
     super();
     this.#connection = connection;
     this.#targetType = targetType;
+    this.#callbacks = new CallbackRegistry(connection._idGenerator);
     this.#sessionId = sessionId;
     this.#parentSessionId = parentSessionId;
     this.#rawErrors = rawErrors;
@@ -70,7 +71,7 @@ export class CdpCDPSession extends CDPSession {
     return this.#target;
   }
 
-  override connection(): Connection | undefined {
+  override connection(): Connection {
     return this.#connection;
   }
 

package/src/cdp/Connection.ts

@@ -19,6 +19,10 @@ import {debug} from '../common/Debug.js';
 import {ConnectionClosedError, TargetCloseError} from '../common/Errors.js';
 import {EventEmitter} from '../common/EventEmitter.js';
 import {createProtocolErrorMessage} from '../util/ErrorLike.js';
+import {
+  createIncrementalIdGenerator,
+  type GetIdFn,
+} from '../util/incremental-id-generator.js';
 
 import {CdpCDPSession} from './CdpSession.js';
 
@@ -38,6 +42,7 @@ export class Connection extends EventEmitter<CDPSessionEvents> {
   #manuallyAttached = new Set<string>();
   #callbacks: CallbackRegistry;
   #rawErrors = false;
+  #idGenerator: GetIdFn;
 
   constructor(
     url: string,
@@ -45,10 +50,12 @@ export class Connection extends EventEmitter<CDPSessionEvents> {
     delay = 0,
     timeout?: number,
     rawErrors = false,
+    idGenerator: () => number = createIncrementalIdGenerator(),
   ) {
     super();
     this.#rawErrors = rawErrors;
-    this.#callbacks = new CallbackRegistry();
+    this.#idGenerator = idGenerator;
+    this.#callbacks = new CallbackRegistry(idGenerator);
     this.#url = url;
     this.#delay = delay;
     this.#timeout = timeout ?? 180_000;
@@ -80,6 +87,13 @@ export class Connection extends EventEmitter<CDPSessionEvents> {
     return this.#closed;
   }
 
+  /**
+   * @internal
+   */
+  get _idGenerator(): GetIdFn {
+    return this.#idGenerator;
+  }
+
   /**
    * @internal
    */