brave-real-puppeteer-core 24.25.0 → 24.33.0-patch.1

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
    */

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/ExecutionContext.ts

@@ -597,7 +597,9 @@ export class ExecutionContext
       }
 
       if (returnByValue) {
-        return valueFromRemoteObject(remoteObject);
+        return valueFromRemoteObject(remoteObject) as HandleFor<
+          Awaited<ReturnType<Func>>
+        >;
       }
 
       return this.#world.createCdpHandle(remoteObject) as HandleFor<
@@ -649,7 +651,9 @@ export class ExecutionContext
     }
 
     if (returnByValue) {
-      return valueFromRemoteObject(remoteObject);
+      return valueFromRemoteObject(remoteObject) as unknown as HandleFor<
+        Awaited<ReturnType<Func>>
+      >;
     }
 
     return this.#world.createCdpHandle(remoteObject) as HandleFor<

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;
     }
   }
@@ -138,7 +142,8 @@ export class CdpHTTPRequest extends HTTPRequest {
   }
 
   override headers(): Record<string, string> {
-    return this.#headers;
+    // Callers should not be allowed to mutate internal structure.
+    return structuredClone(this.#headers);
   }
 
   override response(): CdpHTTPResponse | null {

package/src/cdp/HTTPResponse.ts

@@ -139,7 +139,7 @@ export class CdpHTTPResponse extends HTTPResponse {
                 'No resource with given identifier found'
             ) {
               throw new ProtocolError(
-                'Could not load body for this request. This might happen if the request is a preflight request.',
+                'Could not load response body for this request. This might happen if the request is a preflight request.',
               );
             }
 

package/src/cdp/JSHandle.ts

@@ -45,7 +45,7 @@ export class CdpJSHandle<T = unknown> extends JSHandle<T> {
 
   override async jsonValue(): Promise<T> {
     if (!this.#remoteObject.objectId) {
-      return valueFromRemoteObject(this.#remoteObject);
+      return valueFromRemoteObject(this.#remoteObject) as T;
     }
     const value = await this.evaluate(object => {
       return object;

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[] {