brave-real-puppeteer-core 24.26.1 → 24.33.0

package/src/bidi/BrowserConnector.ts

@@ -10,6 +10,7 @@ import type {ConnectionTransport} from '../common/ConnectionTransport.js';
 import type {ConnectOptions} from '../common/ConnectOptions.js';
 import {ProtocolError, UnsupportedOperation} from '../common/Errors.js';
 import {debugError, DEFAULT_VIEWPORT} from '../common/util.js';
+import {createIncrementalIdGenerator} from '../util/incremental-id-generator.js';
 
 import type {BidiBrowser} from './Browser.js';
 import type {BidiConnection} from './Connection.js';
@@ -66,12 +67,17 @@ async function getBiDiConnection(
   closeCallback: BrowserCloseCallback;
 }> {
   const BiDi = await import(/* webpackIgnore: true */ './bidi.js');
-  const {slowMo = 0, protocolTimeout} = options;
+  const {
+    slowMo = 0,
+    protocolTimeout,
+    idGenerator = createIncrementalIdGenerator(),
+  } = options;
 
   // Try pure BiDi first.
   const pureBidiConnection = new BiDi.BidiConnection(
     url,
     connectionTransport,
+    idGenerator,
     slowMo,
     protocolTimeout,
   );
@@ -102,6 +108,7 @@ async function getBiDiConnection(
     slowMo,
     protocolTimeout,
     /* rawErrors= */ true,
+    idGenerator,
   );
 
   const version = await cdpConnection.send('Browser.getVersion');

package/src/bidi/BrowserContext.ts

@@ -6,7 +6,7 @@
 
 import * as Bidi from 'webdriver-bidi-protocol';
 
-import type {Permission} from '../api/Browser.js';
+import type {CreatePageOptions, Permission} from '../api/Browser.js';
 import {WEB_PERMISSION_TO_PROTOCOL_PERMISSION} from '../api/Browser.js';
 import type {BrowserContextEvents} from '../api/BrowserContext.js';
 import {BrowserContext, BrowserContextEvent} from '../api/BrowserContext.js';
@@ -181,12 +181,15 @@ export class BidiBrowserContext extends BrowserContext {
     });
   }
 
-  override async newPage(): Promise<Page> {
+  override async newPage(options?: CreatePageOptions): Promise<Page> {
     using _guard = await this.waitForScreenshotOperations();
 
-    const context = await this.userContext.createBrowsingContext(
-      Bidi.BrowsingContext.CreateType.Tab,
-    );
+    const type =
+      options?.type === 'window'
+        ? Bidi.BrowsingContext.CreateType.Window
+        : Bidi.BrowsingContext.CreateType.Tab;
+
+    const context = await this.userContext.createBrowsingContext(type);
     const page = this.#pages.get(context)!;
     if (!page) {
       throw new Error('Page is not found');
@@ -221,7 +224,7 @@ export class BidiBrowserContext extends BrowserContext {
     return this.#browser;
   }
 
-  override async pages(): Promise<BidiPage[]> {
+  override async pages(_includeAll = false): Promise<BidiPage[]> {
     return [...this.userContext.browsingContexts].map(context => {
       return this.#pages.get(context)!;
     });

package/src/bidi/Connection.ts

@@ -14,6 +14,7 @@ import {ConnectionClosedError} from '../common/Errors.js';
 import type {EventsWithWildcard} from '../common/EventEmitter.js';
 import {EventEmitter} from '../common/EventEmitter.js';
 import {debugError} from '../common/util.js';
+import type {GetIdFn} from '../util/incremental-id-generator.js';
 
 import {BidiCdpSession} from './CDPSession.js';
 import type {
@@ -57,12 +58,13 @@ export class BidiConnection
   #delay: number;
   #timeout = 0;
   #closed = false;
-  #callbacks = new CallbackRegistry();
+  #callbacks: CallbackRegistry;
   #emitters: Array<EventEmitter<any>> = [];
 
   constructor(
     url: string,
     transport: ConnectionTransport,
+    idGenerator: GetIdFn,
     delay = 0,
     timeout?: number,
   ) {
@@ -70,6 +72,7 @@ export class BidiConnection
     this.#url = url;
     this.#delay = delay;
     this.#timeout = timeout ?? 180_000;
+    this.#callbacks = new CallbackRegistry(idGenerator);
 
     this.#transport = transport;
     this.#transport.onmessage = this.onMessage.bind(this);

package/src/bidi/DeviceRequestPrompt.ts

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Copyright 2025 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as Bidi from 'webdriver-bidi-protocol';
+
+import {
+  DeviceRequestPrompt,
+  type DeviceRequestPromptDevice,
+} from '../api/DeviceRequestPrompt.js';
+import {UnsupportedOperation} from '../common/Errors.js';
+import {Deferred} from '../util/Deferred.js';
+
+import type {Session} from './core/Session.js';
+
+/**
+ * @internal
+ */
+export class BidiDeviceRequestPromptManager {
+  readonly #session: Session;
+  readonly #contextId: string;
+  #enabled = false;
+
+  constructor(contextId: string, session: Session) {
+    this.#session = session;
+    this.#contextId = contextId;
+  }
+
+  async #enableIfNeeded(): Promise<void> {
+    if (!this.#enabled) {
+      this.#enabled = true;
+      await this.#session.subscribe(
+        ['bluetooth.requestDevicePromptUpdated'],
+        [this.#contextId],
+      );
+    }
+  }
+
+  async waitForDevicePrompt(
+    timeout: number,
+    signal: AbortSignal | undefined,
+  ): Promise<DeviceRequestPrompt> {
+    const deferred = Deferred.create<DeviceRequestPrompt>({
+      message: `Waiting for \`DeviceRequestPrompt\` failed: ${timeout}ms exceeded`,
+      timeout,
+    });
+
+    const onRequestDevicePromptUpdated = (
+      params: Bidi.Bluetooth.RequestDevicePromptUpdatedParameters,
+    ) => {
+      if (params.context === this.#contextId) {
+        deferred.resolve(
+          new BidiDeviceRequestPrompt(
+            this.#contextId,
+            params.prompt,
+            this.#session,
+            params.devices,
+          ),
+        );
+        this.#session.off(
+          'bluetooth.requestDevicePromptUpdated',
+          onRequestDevicePromptUpdated,
+        );
+      }
+    };
+    this.#session.on(
+      'bluetooth.requestDevicePromptUpdated',
+      onRequestDevicePromptUpdated,
+    );
+
+    if (signal) {
+      signal.addEventListener(
+        'abort',
+        () => {
+          deferred.reject(signal.reason);
+        },
+        {once: true},
+      );
+    }
+
+    await this.#enableIfNeeded();
+
+    return await deferred.valueOrThrow();
+  }
+}
+
+/**
+ * @internal
+ */
+export class BidiDeviceRequestPrompt extends DeviceRequestPrompt {
+  readonly #session: Session;
+  #promptId: string;
+  #contextId: string;
+
+  constructor(
+    contextId: string,
+    promptId: string,
+    session: Session,
+    devices: Bidi.Bluetooth.RequestDeviceInfo[],
+  ) {
+    super();
+    this.#session = session;
+    this.#promptId = promptId;
+    this.#contextId = contextId;
+
+    this.devices.push(
+      ...devices.map(d => {
+        return {
+          id: d.id,
+          name: d.name ?? 'UNKNOWN',
+        };
+      }),
+    );
+  }
+
+  async cancel(): Promise<void> {
+    await this.#session.send('bluetooth.handleRequestDevicePrompt', {
+      context: this.#contextId,
+      prompt: this.#promptId,
+      accept: false,
+    });
+  }
+
+  async select(device: DeviceRequestPromptDevice): Promise<void> {
+    await this.#session.send('bluetooth.handleRequestDevicePrompt', {
+      context: this.#contextId,
+      prompt: this.#promptId,
+      accept: true,
+      device: device.id,
+    });
+  }
+
+  waitForDevice(): never {
+    throw new UnsupportedOperation();
+  }
+}

package/src/bidi/Frame.ts

@@ -21,13 +21,14 @@ import {
   switchMap,
 } from '../../third_party/rxjs/rxjs.js';
 import type {CDPSession} from '../api/CDPSession.js';
+import type {DeviceRequestPrompt} from '../api/DeviceRequestPrompt.js';
 import {
   Frame,
   throwIfDetached,
   type GoToOptions,
   type WaitForOptions,
 } from '../api/Frame.js';
-import {PageEvent} from '../api/Page.js';
+import {PageEvent, type WaitTimeoutOptions} from '../api/Page.js';
 import {Accessibility} from '../cdp/Accessibility.js';
 import type {ConsoleMessageType} from '../common/ConsoleMessage.js';
 import {
@@ -474,8 +475,11 @@ export class BidiFrame extends Frame {
     );
   }
 
-  override waitForDevicePrompt(): never {
-    throw new UnsupportedOperation();
+  override waitForDevicePrompt(
+    options: WaitTimeoutOptions = {},
+  ): Promise<DeviceRequestPrompt> {
+    const {timeout = this.timeoutSettings.timeout(), signal} = options;
+    return this.browsingContext.waitForDevicePrompt(timeout, signal);
   }
 
   override get detached(): boolean {

package/src/bidi/HTTPRequest.ts

@@ -109,17 +109,6 @@ export class BidiHTTPRequest extends HTTPRequest {
     this.#request.on('authenticate', this.#handleAuthentication);
 
     this.#frame.page().trustedEmitter.emit(PageEvent.Request, this);
-
-    if (this.#hasInternalHeaderOverwrite) {
-      this.interception.handlers.push(async () => {
-        await this.continue(
-          {
-            headers: this.headers(),
-          },
-          0,
-        );
-      });
-    }
   }
 
   protected canBeIntercepted(): boolean {
@@ -165,21 +154,6 @@ export class BidiHTTPRequest extends HTTPRequest {
     return await this.#request.fetchPostData();
   }
 
-  get #hasInternalHeaderOverwrite(): boolean {
-    return Boolean(
-      Object.keys(this.#extraHTTPHeaders).length ||
-        Object.keys(this.#userAgentHeaders).length,
-    );
-  }
-
-  get #extraHTTPHeaders(): Record<string, string> {
-    return this.#frame?.page()._extraHTTPHeaders ?? {};
-  }
-
-  get #userAgentHeaders(): Record<string, string> {
-    return this.#frame?.page()._userAgentHeaders ?? {};
-  }
-
   override headers(): Record<string, string> {
     // Callers should not be allowed to mutate internal structure.
     const headers: Record<string, string> = {};
@@ -188,8 +162,6 @@ export class BidiHTTPRequest extends HTTPRequest {
     }
     return {
       ...headers,
-      ...this.#extraHTTPHeaders,
-      ...this.#userAgentHeaders,
     };
   }
 
@@ -223,19 +195,6 @@ export class BidiHTTPRequest extends HTTPRequest {
     return this.#frame;
   }
 
-  override async continue(
-    overrides?: ContinueRequestOverrides,
-    priority?: number | undefined,
-  ): Promise<void> {
-    return await super.continue(
-      {
-        headers: this.#hasInternalHeaderOverwrite ? this.headers() : undefined,
-        ...overrides,
-      },
-      priority,
-    );
-  }
-
   override async _continue(
     overrides: ContinueRequestOverrides = {},
   ): Promise<void> {

package/src/bidi/Page.ts

@@ -8,7 +8,10 @@ import type Protocol from 'devtools-protocol';
 import * as Bidi from 'webdriver-bidi-protocol';
 
 import {firstValueFrom, from, raceWith} from '../../third_party/rxjs/rxjs.js';
+import type {BluetoothEmulation} from '../api/BluetoothEmulation.js';
+import type {WindowId} from '../api/Browser.js';
 import type {CDPSession} from '../api/CDPSession.js';
+import type {DeviceRequestPrompt} from '../api/DeviceRequestPrompt.js';
 import type {BoundingBox} from '../api/ElementHandle.js';
 import type {WaitForOptions} from '../api/Frame.js';
 import type {HTTPResponse} from '../api/HTTPResponse.js';
@@ -17,6 +20,7 @@ import type {
   GeolocationOptions,
   MediaFeature,
   PageEvents,
+  ReloadOptions,
   WaitTimeoutOptions,
 } from '../api/Page.js';
 import {
@@ -44,12 +48,7 @@ import {EventEmitter} from '../common/EventEmitter.js';
 import {FileChooser} from '../common/FileChooser.js';
 import type {PDFOptions} from '../common/PDFOptions.js';
 import type {Awaitable} from '../common/types.js';
-import {
-  evaluationString,
-  isString,
-  parsePDFOptions,
-  timeout,
-} from '../common/util.js';
+import {evaluationString, parsePDFOptions, timeout} from '../common/util.js';
 import type {Viewport} from '../common/Viewport.js';
 import {assert} from '../util/assert.js';
 import {bubble} from '../util/decorators.js';
@@ -137,9 +136,7 @@ export class BidiPage extends Page {
   /**
    * @internal
    */
-  _userAgentHeaders: Record<string, string> = {};
-  #userAgentInterception?: string;
-  #userAgentPreloadScript?: string;
+  #overrideNavigatorPropertiesPreloadScript?: string;
   override async setUserAgent(
     userAgentOrOptions:
       | string
@@ -185,26 +182,9 @@ export class BidiPage extends Page {
     const enable = userAgent !== '';
     userAgent = userAgent ?? (await this.#browserContext.browser().userAgent());
 
-    this._userAgentHeaders = enable
-      ? {
-          'User-Agent': userAgent,
-        }
-      : {};
-
-    this.#userAgentInterception = await this.#toggleInterception(
-      [Bidi.Network.InterceptPhase.BeforeRequestSent],
-      this.#userAgentInterception,
-      enable,
-    );
+    await this.#frame.browsingContext.setUserAgent(enable ? userAgent : null);
 
-    const overrideNavigatorProperties = (
-      userAgent: string,
-      platform: string | undefined,
-    ) => {
-      Object.defineProperty(navigator, 'userAgent', {
-        value: userAgent,
-        configurable: true,
-      });
+    const overrideNavigatorProperties = (platform: string | undefined) => {
       if (platform) {
         Object.defineProperty(navigator, 'platform', {
           value: platform,
@@ -218,16 +198,15 @@ export class BidiPage extends Page {
       frames.push(...frame.childFrames());
     }
 
-    if (this.#userAgentPreloadScript) {
+    if (this.#overrideNavigatorPropertiesPreloadScript) {
       await this.removeScriptToEvaluateOnNewDocument(
-        this.#userAgentPreloadScript,
+        this.#overrideNavigatorPropertiesPreloadScript,
       );
     }
     const [evaluateToken] = await Promise.all([
       enable
         ? this.evaluateOnNewDocument(
             overrideNavigatorProperties,
-            userAgent,
             platform || undefined,
           )
         : undefined,
@@ -236,12 +215,11 @@ export class BidiPage extends Page {
       ...frames.map(frame => {
         return frame.evaluate(
           overrideNavigatorProperties,
-          userAgent,
           platform || undefined,
         );
       }),
     ]);
-    this.#userAgentPreloadScript = evaluateToken?.identifier;
+    this.#overrideNavigatorPropertiesPreloadScript = evaluateToken?.identifier;
   }
 
   override async setBypassCSP(enabled: boolean): Promise<void> {
@@ -278,11 +256,23 @@ export class BidiPage extends Page {
     return this.#frame;
   }
 
+  override async emulateFocusedPage(enabled: boolean): Promise<void> {
+    return await this.#cdpEmulationManager.emulateFocus(enabled);
+  }
+
   override resize(_params: {
     contentWidth: number;
     contentHeight: number;
   }): Promise<void> {
-    throw new Error('Method not implemented for WebDriver BiDi yet.');
+    throw new UnsupportedOperation();
+  }
+
+  override windowId(): Promise<WindowId> {
+    throw new UnsupportedOperation();
+  }
+
+  override openDevTools(): Promise<Page> {
+    throw new UnsupportedOperation();
   }
 
   async focusedFrame(): Promise<BidiFrame> {
@@ -332,11 +322,13 @@ export class BidiPage extends Page {
   }
 
   override async reload(
-    options: WaitForOptions = {},
+    options: ReloadOptions = {},
   ): Promise<BidiHTTPResponse | null> {
     const [response] = await Promise.all([
       this.#frame.waitForNavigation(options),
-      this.#frame.browsingContext.reload(),
+      this.#frame.browsingContext.reload({
+        ignoreCache: options.ignoreCache ? true : undefined,
+      }),
     ]).catch(
       rewriteNavigationError(
         this.url(),
@@ -429,18 +421,42 @@ export class BidiPage extends Page {
 
   override async setViewport(viewport: Viewport | null): Promise<void> {
     if (!this.browser().cdpSupported) {
-      await this.#frame.browsingContext.setViewport({
-        viewport:
-          viewport?.width && viewport?.height
+      const viewportSize =
+        viewport?.width && viewport?.height
+          ? {
+              width: viewport.width,
+              height: viewport.height,
+            }
+          : null;
+
+      const devicePixelRatio = viewport?.deviceScaleFactor
+        ? viewport.deviceScaleFactor
+        : null;
+
+      // If `viewport` is not set, remove screen orientation override.
+      const screenOrientation: Bidi.Emulation.ScreenOrientation | null =
+        viewport
+          ? viewport.isLandscape
             ? {
-                width: viewport.width,
-                height: viewport.height,
+                natural: Bidi.Emulation.ScreenOrientationNatural.Landscape,
+                type: 'landscape-primary',
               }
-            : null,
-        devicePixelRatio: viewport?.deviceScaleFactor
-          ? viewport.deviceScaleFactor
-          : null,
-      });
+            : {
+                natural: Bidi.Emulation.ScreenOrientationNatural.Portrait,
+                type: 'portrait-primary',
+              }
+          : null;
+
+      await Promise.all([
+        this.#frame.browsingContext.setViewport({
+          viewport: viewportSize,
+          devicePixelRatio,
+        }),
+        this.#frame.browsingContext.setScreenOrientationOverride(
+          screenOrientation,
+        ),
+      ]);
+
       this.#viewport = viewport;
       return;
     }
@@ -713,10 +729,7 @@ export class BidiPage extends Page {
 
   get isNetworkInterceptionEnabled(): boolean {
     return (
-      Boolean(this.#requestInterception) ||
-      Boolean(this.#extraHeadersInterception) ||
-      Boolean(this.#authInterception) ||
-      Boolean(this.#userAgentInterception)
+      Boolean(this.#requestInterception) || Boolean(this.#authInterception)
     );
   }
 
@@ -732,26 +745,10 @@ export class BidiPage extends Page {
   /**
    * @internal
    */
-  _extraHTTPHeaders: Record<string, string> = {};
-  #extraHeadersInterception?: string;
   override async setExtraHTTPHeaders(
     headers: Record<string, string>,
   ): Promise<void> {
-    const extraHTTPHeaders: Record<string, string> = {};
-    for (const [key, value] of Object.entries(headers)) {
-      assert(
-        isString(value),
-        `Expected value of header "${key}" to be String, but "${typeof value}" is found.`,
-      );
-      extraHTTPHeaders[key.toLowerCase()] = value;
-    }
-    this._extraHTTPHeaders = extraHTTPHeaders;
-
-    this.#extraHeadersInterception = await this.#toggleInterception(
-      [Bidi.Network.InterceptPhase.BeforeRequestSent],
-      this.#extraHeadersInterception,
-      Boolean(Object.keys(this._extraHTTPHeaders).length),
-    );
+    await this.#frame.browsingContext.setExtraHTTPHeaders(headers);
   }
 
   /**
@@ -797,7 +794,7 @@ export class BidiPage extends Page {
 
   override async setOfflineMode(enabled: boolean): Promise<void> {
     if (!this.#browserContext.browser().cdpSupported) {
-      throw new UnsupportedOperation();
+      return await this.#frame.browsingContext.setOfflineMode(enabled);
     }
 
     if (!this.#emulatedNetworkConditions) {
@@ -816,8 +813,20 @@ export class BidiPage extends Page {
     networkConditions: NetworkConditions | null,
   ): Promise<void> {
     if (!this.#browserContext.browser().cdpSupported) {
-      throw new UnsupportedOperation();
+      if (
+        !networkConditions?.offline &&
+        ((networkConditions?.upload ?? -1) >= 0 ||
+          (networkConditions?.download ?? -1) >= 0 ||
+          (networkConditions?.latency ?? 0) > 0)
+      ) {
+        // WebDriver BiDi supports only offline mode.
+        throw new UnsupportedOperation();
+      }
+      return await this.#frame.browsingContext.setOfflineMode(
+        networkConditions?.offline ?? false,
+      );
     }
+
     if (!this.#emulatedNetworkConditions) {
       this.#emulatedNetworkConditions = {
         offline: networkConditions?.offline ?? false,
@@ -989,8 +998,14 @@ export class BidiPage extends Page {
     }
   }
 
-  override waitForDevicePrompt(): never {
-    throw new UnsupportedOperation();
+  override async waitForDevicePrompt(
+    options: WaitTimeoutOptions = {},
+  ): Promise<DeviceRequestPrompt> {
+    return await this.mainFrame().waitForDevicePrompt(options);
+  }
+
+  override get bluetooth(): BluetoothEmulation {
+    return this.mainFrame().browsingContext.bluetooth;
   }
 }