brave-real-puppeteer-core 24.26.1 → 24.33.0

package/src/cdp/DeviceRequestPrompt.ts

@@ -7,59 +7,17 @@
 import type Protocol from 'devtools-protocol';
 
 import type {CDPSession} from '../api/CDPSession.js';
+import {DeviceRequestPrompt} from '../api/DeviceRequestPrompt.js';
+import type {DeviceRequestPromptDevice} from '../api/DeviceRequestPrompt.js';
 import type {WaitTimeoutOptions} from '../api/Page.js';
 import type {TimeoutSettings} from '../common/TimeoutSettings.js';
 import {assert} from '../util/assert.js';
 import {Deferred} from '../util/Deferred.js';
 
 /**
- * Device in a request prompt.
- *
- * @public
- */
-export class DeviceRequestPromptDevice {
-  /**
-   * Device id during a prompt.
-   */
-  id: string;
-
-  /**
-   * Device name as it appears in a prompt.
-   */
-  name: string;
-
-  /**
-   * @internal
-   */
-  constructor(id: string, name: string) {
-    this.id = id;
-    this.name = name;
-  }
-}
-
-/**
- * Device request prompts let you respond to the page requesting for a device
- * through an API like WebBluetooth.
- *
- * @remarks
- * `DeviceRequestPrompt` instances are returned via the
- * {@link Page.waitForDevicePrompt} method.
- *
- * @example
- *
- * ```ts
- * const [devicePrompt] = Promise.all([
- *   page.waitForDevicePrompt(),
- *   page.click('#connect-bluetooth'),
- * ]);
- * await devicePrompt.select(
- *   await devicePrompt.waitForDevice(({name}) => name.includes('My Device')),
- * );
- * ```
- *
- * @public
+ * @internal
  */
-export class DeviceRequestPrompt {
+export class CdpDeviceRequestPrompt extends DeviceRequestPrompt {
   #client: CDPSession | null;
   #timeoutSettings: TimeoutSettings;
   #id: string;
@@ -70,19 +28,12 @@ export class DeviceRequestPrompt {
     promise: Deferred<DeviceRequestPromptDevice>;
   }>();
 
-  /**
-   * Current list of selectable devices.
-   */
-  devices: DeviceRequestPromptDevice[] = [];
-
-  /**
-   * @internal
-   */
   constructor(
     client: CDPSession,
     timeoutSettings: TimeoutSettings,
     firstEvent: Protocol.DeviceAccess.DeviceRequestPromptedEvent,
   ) {
+    super();
     this.#client = client;
     this.#timeoutSettings = timeoutSettings;
     this.#id = firstEvent.id;
@@ -112,10 +63,7 @@ export class DeviceRequestPrompt {
         continue;
       }
 
-      const newDevice = new DeviceRequestPromptDevice(
-        rawDevice.id,
-        rawDevice.name,
-      );
+      const newDevice = {id: rawDevice.id, name: rawDevice.name};
       this.devices.push(newDevice);
 
       for (const waitForDevicePromise of this.#waitForDevicePromises) {
@@ -126,9 +74,6 @@ export class DeviceRequestPrompt {
     }
   }
 
-  /**
-   * Resolve to the first device in the prompt matching a filter.
-   */
   async waitForDevice(
     filter: (device: DeviceRequestPromptDevice) => boolean,
     options: WaitTimeoutOptions = {},
@@ -164,9 +109,6 @@ export class DeviceRequestPrompt {
     }
   }
 
-  /**
-   * Select a device in the prompt's list.
-   */
   async select(device: DeviceRequestPromptDevice): Promise<void> {
     assert(
       this.#client !== null,
@@ -188,9 +130,6 @@ export class DeviceRequestPrompt {
     });
   }
 
-  /**
-   * Cancel the prompt.
-   */
   async cancel(): Promise<void> {
     assert(
       this.#client !== null,
@@ -212,14 +151,11 @@ export class DeviceRequestPrompt {
 /**
  * @internal
  */
-export class DeviceRequestPromptManager {
+export class CdpDeviceRequestPromptManager {
   #client: CDPSession | null;
   #timeoutSettings: TimeoutSettings;
   #deviceRequestPromptDeferreds = new Set<Deferred<DeviceRequestPrompt>>();
 
-  /**
-   * @internal
-   */
   constructor(client: CDPSession, timeoutSettings: TimeoutSettings) {
     this.#client = client;
     this.#timeoutSettings = timeoutSettings;
@@ -232,10 +168,6 @@ export class DeviceRequestPromptManager {
     });
   }
 
-  /**
-   * Wait for device prompt created by an action like calling WebBluetooth's
-   * requestDevice.
-   */
   async waitForDevicePrompt(
     options: WaitTimeoutOptions = {},
   ): Promise<DeviceRequestPrompt> {
@@ -277,9 +209,6 @@ export class DeviceRequestPromptManager {
     }
   }
 
-  /**
-   * @internal
-   */
   #onDeviceRequestPrompted(
     event: Protocol.DeviceAccess.DeviceRequestPromptedEvent,
   ) {
@@ -288,7 +217,7 @@ export class DeviceRequestPromptManager {
     }
 
     assert(this.#client !== null);
-    const devicePrompt = new DeviceRequestPrompt(
+    const devicePrompt = new CdpDeviceRequestPrompt(
       this.#client,
       this.#timeoutSettings,
       event,

package/src/cdp/EmulationManager.ts

@@ -66,6 +66,11 @@ interface JavascriptEnabledState {
   active: boolean;
 }
 
+interface FocusState {
+  enabled: boolean;
+  active: boolean;
+}
+
 /**
  * @internal
  */
@@ -193,6 +198,14 @@ export class EmulationManager implements ClientProvider {
     this,
     this.#setJavaScriptEnabled,
   );
+  #focusState = new EmulatedState<FocusState>(
+    {
+      enabled: true,
+      active: false,
+    },
+    this,
+    this.#emulateFocus,
+  );
 
   #secondaryClients = new Set<CDPSession>();
 
@@ -578,4 +591,21 @@ export class EmulationManager implements ClientProvider {
       javaScriptEnabled: enabled,
     });
   }
+
+  @invokeAtMostOnceForArguments
+  async #emulateFocus(client: CDPSession, state: FocusState): Promise<void> {
+    if (!state.active) {
+      return;
+    }
+    await client.send('Emulation.setFocusEmulationEnabled', {
+      enabled: state.enabled,
+    });
+  }
+
+  async emulateFocus(enabled: boolean): Promise<void> {
+    await this.#focusState.setState({
+      active: true,
+      enabled,
+    });
+  }
 }

package/src/cdp/ExtensionTransport.ts

@@ -68,7 +68,10 @@ export class ExtensionTransport implements ConnectionTransport {
   };
 
   #dispatchResponse(message: object): void {
-    this.onmessage?.(JSON.stringify(message));
+    // Dispatch in a new task like other transports.
+    setTimeout(() => {
+      this.onmessage?.(JSON.stringify(message));
+    }, 0);
   }
 
   send(message: string): void {
@@ -125,6 +128,7 @@ export class ExtensionTransport implements ConnectionTransport {
         if (parsed.sessionId === 'tabTargetSessionId') {
           this.#dispatchResponse({
             method: 'Target.attachedToTarget',
+            sessionId: 'tabTargetSessionId',
             params: {
               targetInfo: pageTargetInfo,
               sessionId: 'pageTargetSessionId',

package/src/cdp/Frame.ts

@@ -7,6 +7,7 @@
 import type {Protocol} from 'devtools-protocol';
 
 import type {CDPSession} from '../api/CDPSession.js';
+import type {DeviceRequestPrompt} from '../api/DeviceRequestPrompt.js';
 import type {ElementHandle} from '../api/ElementHandle.js';
 import type {WaitForOptions} from '../api/Frame.js';
 import {Frame, FrameEvent, throwIfDetached} from '../api/Frame.js';
@@ -21,10 +22,7 @@ import {isErrorLike} from '../util/ErrorLike.js';
 import {Accessibility} from './Accessibility.js';
 import type {Binding} from './Binding.js';
 import type {CdpPreloadScript} from './CdpPreloadScript.js';
-import type {
-  DeviceRequestPrompt,
-  DeviceRequestPromptManager,
-} from './DeviceRequestPrompt.js';
+import type {CdpDeviceRequestPromptManager} from './DeviceRequestPrompt.js';
 import type {FrameManager} from './FrameManager.js';
 import {FrameManagerEvent} from './FrameManagerEvents.js';
 import type {IsolatedWorldChart} from './IsolatedWorld.js';
@@ -317,7 +315,7 @@ export class CdpFrame extends Frame {
     return this._frameManager._frameTree.childFrames(this._id);
   }
 
-  #deviceRequestPromptManager(): DeviceRequestPromptManager {
+  #deviceRequestPromptManager(): CdpDeviceRequestPromptManager {
     return this._frameManager._deviceRequestPromptManager(this.#client);
   }
 

package/src/cdp/FrameManager.ts

@@ -21,7 +21,7 @@ import type {Binding} from './Binding.js';
 import {CdpPreloadScript} from './CdpPreloadScript.js';
 import type {CdpCDPSession} from './CdpSession.js';
 import {isTargetClosedError} from './Connection.js';
-import {DeviceRequestPromptManager} from './DeviceRequestPrompt.js';
+import {CdpDeviceRequestPromptManager} from './DeviceRequestPrompt.js';
 import {ExecutionContext} from './ExecutionContext.js';
 import {CdpFrame} from './Frame.js';
 import type {FrameManagerEvents} from './FrameManagerEvents.js';
@@ -60,7 +60,7 @@ export class FrameManager extends EventEmitter<FrameManagerEvents> {
 
   #deviceRequestPromptManagerMap = new WeakMap<
     CDPSession,
-    DeviceRequestPromptManager
+    CdpDeviceRequestPromptManager
   >();
 
   #frameTreeHandled?: Deferred<void>;
@@ -380,10 +380,15 @@ export class FrameManager extends EventEmitter<FrameManagerEvents> {
     void this.initialize(target._session()!, frame);
   }
 
-  _deviceRequestPromptManager(client: CDPSession): DeviceRequestPromptManager {
+  _deviceRequestPromptManager(
+    client: CDPSession,
+  ): CdpDeviceRequestPromptManager {
     let manager = this.#deviceRequestPromptManagerMap.get(client);
     if (manager === undefined) {
-      manager = new DeviceRequestPromptManager(client, this.#timeoutSettings);
+      manager = new CdpDeviceRequestPromptManager(
+        client,
+        this.#timeoutSettings,
+      );
       this.#deviceRequestPromptManagerMap.set(client, manager);
     }
     return manager;

package/src/cdp/HTTPRequest.ts

@@ -100,7 +100,11 @@ export class CdpHTTPRequest extends HTTPRequest {
 
     this.interception.enabled = allowInterception;
 
-    for (const [key, value] of Object.entries(data.request.headers)) {
+    this.updateHeaders(data.request.headers);
+  }
+
+  updateHeaders(headers: Protocol.Network.Headers): void {
+    for (const [key, value] of Object.entries(headers)) {
       this.#headers[key.toLowerCase()] = value;
     }
   }

package/src/cdp/NetworkEventManager.ts

@@ -83,7 +83,10 @@ export class NetworkEventManager {
     Protocol.Fetch.RequestPausedEvent
   >();
   #httpRequestsMap = new Map<NetworkRequestId, CdpHTTPRequest>();
-
+  #requestWillBeSentExtraInfoMap = new Map<
+    NetworkRequestId,
+    Protocol.Network.RequestWillBeSentExtraInfoEvent[]
+  >();
   /*
    * The below maps are used to reconcile Network.responseReceivedExtraInfo
    * events with their corresponding request. Each response and redirect
@@ -103,11 +106,23 @@ export class NetworkEventManager {
   forget(networkRequestId: NetworkRequestId): void {
     this.#requestWillBeSentMap.delete(networkRequestId);
     this.#requestPausedMap.delete(networkRequestId);
+    this.#requestWillBeSentExtraInfoMap.delete(networkRequestId);
     this.#queuedEventGroupMap.delete(networkRequestId);
     this.#queuedRedirectInfoMap.delete(networkRequestId);
     this.#responseReceivedExtraInfoMap.delete(networkRequestId);
   }
 
+  requestExtraInfo(
+    networkRequestId: NetworkRequestId,
+  ): Protocol.Network.RequestWillBeSentExtraInfoEvent[] {
+    if (!this.#requestWillBeSentExtraInfoMap.has(networkRequestId)) {
+      this.#requestWillBeSentExtraInfoMap.set(networkRequestId, []);
+    }
+    return this.#requestWillBeSentExtraInfoMap.get(
+      networkRequestId,
+    ) as Protocol.Network.RequestWillBeSentExtraInfoEvent[];
+  }
+
   responseExtraInfo(
     networkRequestId: NetworkRequestId,
   ): Protocol.Network.ResponseReceivedExtraInfoEvent[] {

package/src/cdp/NetworkManager.ts

@@ -88,6 +88,7 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
     ['Fetch.requestPaused', this.#onRequestPaused],
     ['Fetch.authRequired', this.#onAuthRequired],
     ['Network.requestWillBeSent', this.#onRequestWillBeSent],
+    ['Network.requestWillBeSentExtraInfo', this.#onRequestWillBeSentExtraInfo],
     ['Network.requestServedFromCache', this.#onRequestServedFromCache],
     ['Network.responseReceived', this.#onResponseReceived],
     ['Network.loadingFinished', this.#onLoadingFinished],
@@ -108,7 +109,9 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
   #canIgnoreError(error: unknown) {
     return (
       isErrorLike(error) &&
-      (isTargetClosedError(error) || error.message.includes('Not supported'))
+      (isTargetClosedError(error) ||
+        error.message.includes('Not supported') ||
+        error.message.includes("wasn't found"))
     );
   }
 
@@ -534,6 +537,13 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
           redirectResponseExtraInfo,
         );
         redirectChain = request._redirectChain;
+
+        const extraInfo = this.#networkEventManager
+          .requestExtraInfo(event.requestId)
+          .shift();
+        if (extraInfo) {
+          request.updateHeaders(extraInfo.headers);
+        }
       }
     }
     const frame = event.frameId
@@ -548,12 +558,32 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
       event,
       redirectChain,
     );
+
+    const extraInfo = this.#networkEventManager
+      .requestExtraInfo(event.requestId)
+      .shift();
+    if (extraInfo) {
+      request.updateHeaders(extraInfo.headers);
+    }
+
     request._fromMemoryCache = fromMemoryCache;
     this.#networkEventManager.storeRequest(event.requestId, request);
     this.emit(NetworkManagerEvent.Request, request);
     void request.finalizeInterceptions();
   }
 
+  #onRequestWillBeSentExtraInfo(
+    _client: CDPSession,
+    event: Protocol.Network.RequestWillBeSentExtraInfoEvent,
+  ): void {
+    const request = this.#networkEventManager.getRequest(event.requestId);
+    if (request) {
+      request.updateHeaders(event.headers);
+    } else {
+      this.#networkEventManager.requestExtraInfo(event.requestId).push(event);
+    }
+  }
+
   #onRequestServedFromCache(
     client: CDPSession,
     event: Protocol.Network.RequestServedFromCacheEvent,

package/src/cdp/Page.ts

@@ -7,14 +7,16 @@
 import type {Protocol} from 'devtools-protocol';
 
 import {firstValueFrom, from, raceWith} from '../../third_party/rxjs/rxjs.js';
-import type {Browser} from '../api/Browser.js';
+import type {BluetoothEmulation} from '../api/BluetoothEmulation.js';
+import type {Browser, WindowId} from '../api/Browser.js';
 import type {BrowserContext} from '../api/BrowserContext.js';
 import {CDPSessionEvent, type CDPSession} from '../api/CDPSession.js';
+import type {DeviceRequestPrompt} from '../api/DeviceRequestPrompt.js';
 import type {ElementHandle} from '../api/ElementHandle.js';
 import type {Frame, WaitForOptions} from '../api/Frame.js';
 import type {HTTPResponse} from '../api/HTTPResponse.js';
 import type {JSHandle} from '../api/JSHandle.js';
-import type {Credentials} from '../api/Page.js';
+import type {Credentials, ReloadOptions} from '../api/Page.js';
 import {
   Page,
   PageEvent,
@@ -58,10 +60,11 @@ import {AsyncDisposableStack} from '../util/disposable.js';
 import {isErrorLike} from '../util/ErrorLike.js';
 
 import {Binding} from './Binding.js';
+import {CdpBluetoothEmulation} from './BluetoothEmulation.js';
+import type {CdpBrowser} from './Browser.js';
 import {CdpCDPSession} from './CdpSession.js';
 import {isTargetClosedError} from './Connection.js';
 import {Coverage} from './Coverage.js';
-import type {DeviceRequestPrompt} from './DeviceRequestPrompt.js';
 import {CdpDialog} from './Dialog.js';
 import {EmulationManager} from './EmulationManager.js';
 import type {CdpFrame} from './Frame.js';
@@ -119,6 +122,7 @@ export class CdpPage extends Page {
 
   #closed = false;
   readonly #targetManager: TargetManager;
+  readonly #cdpBluetoothEmulation: CdpBluetoothEmulation;
 
   #primaryTargetClient: CdpCDPSession;
   #primaryTarget: CdpTarget;
@@ -158,6 +162,12 @@ export class CdpPage extends Page {
     this.#coverage = new Coverage(client);
     this.#viewport = null;
 
+    // Use browser context's connection, as current Bluetooth emulation in Chromium is
+    // implemented on the browser context level, and not tight to the specific tab.
+    this.#cdpBluetoothEmulation = new CdpBluetoothEmulation(
+      this.#primaryTargetClient.connection(),
+    );
+
     const frameManagerEmitter = new EventEmitter(this.#frameManager);
     frameManagerEmitter.on(FrameManagerEvent.FrameAttached, frame => {
       this.emit(PageEvent.FrameAttached, frame);
@@ -365,17 +375,22 @@ export class CdpPage extends Page {
     contentWidth: number;
     contentHeight: number;
   }): Promise<void> {
-    const {windowId} = await this.#primaryTargetClient.send(
-      'Browser.getWindowForTarget',
-    );
-
+    const windowId = await this.windowId();
     await this.#primaryTargetClient.send('Browser.setContentsSize', {
-      windowId,
+      windowId: Number(windowId),
       width: params.contentWidth,
       height: params.contentHeight,
     });
   }
 
+  override async windowId(): Promise<WindowId> {
+    const {windowId} = await this.#primaryTargetClient.send(
+      'Browser.getWindowForTarget',
+    );
+
+    return windowId.toString();
+  }
+
   async #onFileChooser(
     event: Protocol.Page.FileChooserOpenedEvent,
   ): Promise<void> {
@@ -417,6 +432,13 @@ export class CdpPage extends Page {
     return this.#emulationManager.javascriptEnabled;
   }
 
+  override async openDevTools(): Promise<Page> {
+    const pageTargetId = this.target()._targetId;
+    const browser = this.browser() as CdpBrowser;
+    const devtoolsPage = await browser._createDevToolsPage(pageTargetId);
+    return devtoolsPage;
+  }
+
   override async waitForFileChooser(
     options: WaitTimeoutOptions = {},
   ): Promise<FileChooser> {
@@ -480,7 +502,8 @@ export class CdpPage extends Page {
   }
 
   #onLogEntryAdded(event: Protocol.Log.EntryAddedEvent): void {
-    const {level, text, args, source, url, lineNumber} = event.entry;
+    const {level, text, args, source, url, lineNumber, stackTrace} =
+      event.entry;
     if (args) {
       args.map(arg => {
         void releaseObject(this.#primaryTargetClient, arg);
@@ -494,6 +517,8 @@ export class CdpPage extends Page {
           text,
           [],
           [{url, lineNumber}],
+          undefined,
+          stackTrace,
         ),
       );
     }
@@ -560,6 +585,10 @@ export class CdpPage extends Page {
     );
   }
 
+  override async emulateFocusedPage(enabled: boolean): Promise<void> {
+    return await this.#emulationManager.emulateFocus(enabled);
+  }
+
   override setDefaultNavigationTimeout(timeout: number): void {
     this._timeoutSettings.setDefaultNavigationTimeout(timeout);
   }
@@ -883,6 +912,8 @@ export class CdpPage extends Page {
       textTokens.join(' '),
       args,
       stackTraceLocations,
+      undefined,
+      stackTrace,
     );
     this.emit(PageEvent.Console, message);
   }
@@ -898,15 +929,15 @@ export class CdpPage extends Page {
     this.emit(PageEvent.Dialog, dialog);
   }
 
-  override async reload(
-    options?: WaitForOptions,
-  ): Promise<HTTPResponse | null> {
+  override async reload(options?: ReloadOptions): Promise<HTTPResponse | null> {
     const [result] = await Promise.all([
       this.waitForNavigation({
         ...options,
         ignoreSameDocumentNavigation: true,
       }),
-      this.#primaryTargetClient.send('Page.reload'),
+      this.#primaryTargetClient.send('Page.reload', {
+        ignoreCache: options?.ignoreCache ?? false,
+      }),
     ]);
 
     return result;
@@ -1219,6 +1250,10 @@ export class CdpPage extends Page {
   ): Promise<DeviceRequestPrompt> {
     return await this.mainFrame().waitForDevicePrompt(options);
   }
+
+  override get bluetooth(): BluetoothEmulation {
+    return this.#cdpBluetoothEmulation;
+  }
 }
 
 const supportedMetrics = new Set<string>([