rebrowser-puppeteer-core 22.13.1

package/src/bidi/core/Session.ts

@@ -0,0 +1,162 @@
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as Bidi from 'chromium-bidi/lib/cjs/protocol/protocol.js';
+
+import {EventEmitter} from '../../common/EventEmitter.js';
+import {
+  bubble,
+  inertIfDisposed,
+  throwIfDisposed,
+} from '../../util/decorators.js';
+import {DisposableStack, disposeSymbol} from '../../util/disposable.js';
+
+import {Browser} from './Browser.js';
+import type {BidiEvents, Commands, Connection} from './Connection.js';
+
+/**
+ * @internal
+ */
+export class Session
+  extends EventEmitter<BidiEvents & {ended: {reason: string}}>
+  implements Connection<BidiEvents & {ended: {reason: string}}>
+{
+  static async from(
+    connection: Connection,
+    capabilities: Bidi.Session.CapabilitiesRequest
+  ): Promise<Session> {
+    const {result} = await connection.send('session.new', {
+      capabilities,
+    });
+
+    const session = new Session(connection, result);
+    await session.#initialize();
+    return session;
+  }
+
+  #reason: string | undefined;
+  readonly #disposables = new DisposableStack();
+  readonly #info: Bidi.Session.NewResult;
+  readonly browser!: Browser;
+  @bubble()
+  accessor connection: Connection;
+
+  private constructor(connection: Connection, info: Bidi.Session.NewResult) {
+    super();
+
+    this.#info = info;
+    this.connection = connection;
+  }
+
+  async #initialize(): Promise<void> {
+    // SAFETY: We use `any` to allow assignment of the readonly property.
+    (this as any).browser = await Browser.from(this);
+
+    const browserEmitter = this.#disposables.use(this.browser);
+    browserEmitter.once('closed', ({reason}) => {
+      this.dispose(reason);
+    });
+
+    // TODO: Currently, some implementations do not emit navigationStarted event
+    // for fragment navigations (as per spec) and some do. This could emits a
+    // synthetic navigationStarted to work around this inconsistency.
+    const seen = new WeakSet();
+    this.on('browsingContext.fragmentNavigated', info => {
+      if (seen.has(info)) {
+        return;
+      }
+      seen.add(info);
+      this.emit('browsingContext.navigationStarted', info);
+      this.emit('browsingContext.fragmentNavigated', info);
+    });
+  }
+
+  get capabilities(): Bidi.Session.NewResult['capabilities'] {
+    return this.#info.capabilities;
+  }
+  get disposed(): boolean {
+    return this.ended;
+  }
+  get ended(): boolean {
+    return this.#reason !== undefined;
+  }
+  get id(): string {
+    return this.#info.sessionId;
+  }
+
+  @inertIfDisposed
+  private dispose(reason?: string): void {
+    this.#reason = reason;
+    this[disposeSymbol]();
+  }
+
+  /**
+   * Currently, there is a 1:1 relationship between the session and the
+   * session. In the future, we might support multiple sessions and in that
+   * case we always needs to make sure that the session for the right session
+   * object is used, so we implement this method here, although it's not defined
+   * in the spec.
+   */
+  @throwIfDisposed<Session>(session => {
+    // SAFETY: By definition of `disposed`, `#reason` is defined.
+    return session.#reason!;
+  })
+  async send<T extends keyof Commands>(
+    method: T,
+    params: Commands[T]['params']
+  ): Promise<{result: Commands[T]['returnType']}> {
+    return await this.connection.send(method, params);
+  }
+
+  @throwIfDisposed<Session>(session => {
+    // SAFETY: By definition of `disposed`, `#reason` is defined.
+    return session.#reason!;
+  })
+  async subscribe(
+    events: [string, ...string[]],
+    contexts?: [string, ...string[]]
+  ): Promise<void> {
+    await this.send('session.subscribe', {
+      events,
+      contexts,
+    });
+  }
+
+  @throwIfDisposed<Session>(session => {
+    // SAFETY: By definition of `disposed`, `#reason` is defined.
+    return session.#reason!;
+  })
+  async addIntercepts(
+    events: [string, ...string[]],
+    contexts?: [string, ...string[]]
+  ): Promise<void> {
+    await this.send('session.subscribe', {
+      events,
+      contexts,
+    });
+  }
+
+  @throwIfDisposed<Session>(session => {
+    // SAFETY: By definition of `disposed`, `#reason` is defined.
+    return session.#reason!;
+  })
+  async end(): Promise<void> {
+    try {
+      await this.send('session.end', {});
+    } finally {
+      this.dispose(`Session already ended.`);
+    }
+  }
+
+  [disposeSymbol](): void {
+    this.#reason ??=
+      'Session already destroyed, probably because the connection broke.';
+    this.emit('ended', {reason: this.#reason});
+
+    this.#disposables.dispose();
+    super[disposeSymbol]();
+  }
+}

package/src/bidi/core/UserContext.ts

@@ -0,0 +1,238 @@
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as Bidi from 'chromium-bidi/lib/cjs/protocol/protocol.js';
+
+import {EventEmitter} from '../../common/EventEmitter.js';
+import {assert} from '../../util/assert.js';
+import {inertIfDisposed, throwIfDisposed} from '../../util/decorators.js';
+import {DisposableStack, disposeSymbol} from '../../util/disposable.js';
+
+import type {Browser} from './Browser.js';
+import type {GetCookiesOptions} from './BrowsingContext.js';
+import {BrowsingContext} from './BrowsingContext.js';
+
+/**
+ * @internal
+ */
+export type CreateBrowsingContextOptions = Omit<
+  Bidi.BrowsingContext.CreateParameters,
+  'type' | 'referenceContext'
+> & {
+  referenceContext?: BrowsingContext;
+};
+
+/**
+ * @internal
+ */
+export class UserContext extends EventEmitter<{
+  /**
+   * Emitted when a new browsing context is created.
+   */
+  browsingcontext: {
+    /** The new browsing context. */
+    browsingContext: BrowsingContext;
+  };
+  /**
+   * Emitted when the user context is closed.
+   */
+  closed: {
+    /** The reason the user context was closed. */
+    reason: string;
+  };
+}> {
+  static DEFAULT = 'default' as const;
+
+  static create(browser: Browser, id: string): UserContext {
+    const context = new UserContext(browser, id);
+    context.#initialize();
+    return context;
+  }
+
+  #reason?: string;
+  // Note these are only top-level contexts.
+  readonly #browsingContexts = new Map<string, BrowsingContext>();
+  readonly #disposables = new DisposableStack();
+  readonly #id: string;
+  readonly browser: Browser;
+
+  private constructor(browser: Browser, id: string) {
+    super();
+
+    this.#id = id;
+    this.browser = browser;
+  }
+
+  #initialize() {
+    const browserEmitter = this.#disposables.use(
+      new EventEmitter(this.browser)
+    );
+    browserEmitter.once('closed', ({reason}) => {
+      this.dispose(`User context already closed: ${reason}`);
+    });
+
+    const sessionEmitter = this.#disposables.use(
+      new EventEmitter(this.#session)
+    );
+    sessionEmitter.on('browsingContext.contextCreated', info => {
+      if (info.parent) {
+        return;
+      }
+
+      if (info.userContext !== this.#id) {
+        return;
+      }
+
+      const browsingContext = BrowsingContext.from(
+        this,
+        undefined,
+        info.context,
+        info.url,
+        info.originalOpener
+      );
+      this.#browsingContexts.set(browsingContext.id, browsingContext);
+
+      const browsingContextEmitter = this.#disposables.use(
+        new EventEmitter(browsingContext)
+      );
+      browsingContextEmitter.on('closed', () => {
+        browsingContextEmitter.removeAllListeners();
+
+        this.#browsingContexts.delete(browsingContext.id);
+      });
+
+      this.emit('browsingcontext', {browsingContext});
+    });
+  }
+
+  get #session() {
+    return this.browser.session;
+  }
+  get browsingContexts(): Iterable<BrowsingContext> {
+    return this.#browsingContexts.values();
+  }
+  get closed(): boolean {
+    return this.#reason !== undefined;
+  }
+  get disposed(): boolean {
+    return this.closed;
+  }
+  get id(): string {
+    return this.#id;
+  }
+
+  @inertIfDisposed
+  private dispose(reason?: string): void {
+    this.#reason = reason;
+    this[disposeSymbol]();
+  }
+
+  @throwIfDisposed<UserContext>(context => {
+    // SAFETY: Disposal implies this exists.
+    return context.#reason!;
+  })
+  async createBrowsingContext(
+    type: Bidi.BrowsingContext.CreateType,
+    options: CreateBrowsingContextOptions = {}
+  ): Promise<BrowsingContext> {
+    const {
+      result: {context: contextId},
+    } = await this.#session.send('browsingContext.create', {
+      type,
+      ...options,
+      referenceContext: options.referenceContext?.id,
+      userContext: this.#id,
+    });
+
+    const browsingContext = this.#browsingContexts.get(contextId);
+    assert(
+      browsingContext,
+      'The WebDriver BiDi implementation is failing to create a browsing context correctly.'
+    );
+
+    // We use an array to avoid the promise from being awaited.
+    return browsingContext;
+  }
+
+  @throwIfDisposed<UserContext>(context => {
+    // SAFETY: Disposal implies this exists.
+    return context.#reason!;
+  })
+  async remove(): Promise<void> {
+    try {
+      await this.#session.send('browser.removeUserContext', {
+        userContext: this.#id,
+      });
+    } finally {
+      this.dispose('User context already closed.');
+    }
+  }
+
+  @throwIfDisposed<UserContext>(context => {
+    // SAFETY: Disposal implies this exists.
+    return context.#reason!;
+  })
+  async getCookies(
+    options: GetCookiesOptions = {},
+    sourceOrigin: string | undefined = undefined
+  ): Promise<Bidi.Network.Cookie[]> {
+    const {
+      result: {cookies},
+    } = await this.#session.send('storage.getCookies', {
+      ...options,
+      partition: {
+        type: 'storageKey',
+        userContext: this.#id,
+        sourceOrigin,
+      },
+    });
+    return cookies;
+  }
+
+  @throwIfDisposed<UserContext>(context => {
+    // SAFETY: Disposal implies this exists.
+    return context.#reason!;
+  })
+  async setCookie(
+    cookie: Bidi.Storage.PartialCookie,
+    sourceOrigin?: string
+  ): Promise<void> {
+    await this.#session.send('storage.setCookie', {
+      cookie,
+      partition: {
+        type: 'storageKey',
+        sourceOrigin,
+        userContext: this.id,
+      },
+    });
+  }
+
+  @throwIfDisposed<UserContext>(context => {
+    // SAFETY: Disposal implies this exists.
+    return context.#reason!;
+  })
+  async setPermissions(
+    origin: string,
+    descriptor: Bidi.Permissions.PermissionDescriptor,
+    state: Bidi.Permissions.PermissionState
+  ): Promise<void> {
+    await this.#session.send('permissions.setPermission', {
+      origin,
+      descriptor,
+      state,
+      userContext: this.#id,
+    });
+  }
+
+  [disposeSymbol](): void {
+    this.#reason ??=
+      'User context already closed, probably because the browser disconnected/closed.';
+    this.emit('closed', {reason: this.#reason});
+
+    this.#disposables.dispose();
+    super[disposeSymbol]();
+  }
+}

package/src/bidi/core/UserPrompt.ts

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Bidi from 'chromium-bidi/lib/cjs/protocol/protocol.js';
+
+import {EventEmitter} from '../../common/EventEmitter.js';
+import {inertIfDisposed, throwIfDisposed} from '../../util/decorators.js';
+import {DisposableStack, disposeSymbol} from '../../util/disposable.js';
+
+import type {BrowsingContext} from './BrowsingContext.js';
+
+/**
+ * @internal
+ */
+export type HandleOptions = Omit<
+  Bidi.BrowsingContext.HandleUserPromptParameters,
+  'context'
+>;
+
+/**
+ * @internal
+ */
+export type UserPromptResult = Omit<
+  Bidi.BrowsingContext.UserPromptClosedParameters,
+  'context'
+>;
+
+/**
+ * @internal
+ */
+export class UserPrompt extends EventEmitter<{
+  /** Emitted when the user prompt is handled. */
+  handled: UserPromptResult;
+  /** Emitted when the user prompt is closed. */
+  closed: {
+    /** The reason the user prompt was closed. */
+    reason: string;
+  };
+}> {
+  static from(
+    browsingContext: BrowsingContext,
+    info: Bidi.BrowsingContext.UserPromptOpenedParameters
+  ): UserPrompt {
+    const userPrompt = new UserPrompt(browsingContext, info);
+    userPrompt.#initialize();
+    return userPrompt;
+  }
+
+  #reason?: string;
+  #result?: UserPromptResult;
+  readonly #disposables = new DisposableStack();
+  readonly browsingContext: BrowsingContext;
+  readonly info: Bidi.BrowsingContext.UserPromptOpenedParameters;
+
+  private constructor(
+    context: BrowsingContext,
+    info: Bidi.BrowsingContext.UserPromptOpenedParameters
+  ) {
+    super();
+
+    this.browsingContext = context;
+    this.info = info;
+  }
+
+  #initialize() {
+    const browserContextEmitter = this.#disposables.use(
+      new EventEmitter(this.browsingContext)
+    );
+    browserContextEmitter.once('closed', ({reason}) => {
+      this.dispose(`User prompt already closed: ${reason}`);
+    });
+
+    const sessionEmitter = this.#disposables.use(
+      new EventEmitter(this.#session)
+    );
+    sessionEmitter.on('browsingContext.userPromptClosed', parameters => {
+      if (parameters.context !== this.browsingContext.id) {
+        return;
+      }
+      this.#result = parameters;
+      this.emit('handled', parameters);
+      this.dispose('User prompt already handled.');
+    });
+  }
+
+  get #session() {
+    return this.browsingContext.userContext.browser.session;
+  }
+  get closed(): boolean {
+    return this.#reason !== undefined;
+  }
+  get disposed(): boolean {
+    return this.closed;
+  }
+  get handled(): boolean {
+    if (
+      this.info.handler === Bidi.Session.UserPromptHandlerType.Accept ||
+      this.info.handler === Bidi.Session.UserPromptHandlerType.Dismiss
+    ) {
+      return true;
+    }
+    return this.#result !== undefined;
+  }
+  get result(): UserPromptResult | undefined {
+    return this.#result;
+  }
+
+  @inertIfDisposed
+  private dispose(reason?: string): void {
+    this.#reason = reason;
+    this[disposeSymbol]();
+  }
+
+  @throwIfDisposed<UserPrompt>(prompt => {
+    // SAFETY: Disposal implies this exists.
+    return prompt.#reason!;
+  })
+  async handle(options: HandleOptions = {}): Promise<UserPromptResult> {
+    await this.#session.send('browsingContext.handleUserPrompt', {
+      ...options,
+      context: this.info.context,
+    });
+    // SAFETY: `handled` is triggered before the above promise resolved.
+    return this.#result!;
+  }
+
+  [disposeSymbol](): void {
+    this.#reason ??=
+      'User prompt already closed, probably because the associated browsing context was destroyed.';
+    this.emit('closed', {reason: this.#reason});
+
+    this.#disposables.dispose();
+    super[disposeSymbol]();
+  }
+}

package/src/bidi/core/core.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export * from './Browser.js';
+export * from './BrowsingContext.js';
+export * from './Connection.js';
+export * from './Navigation.js';
+export * from './Realm.js';
+export * from './Request.js';
+export * from './Session.js';
+export * from './UserContext.js';
+export * from './UserPrompt.js';

package/src/bidi/util.ts

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as Bidi from 'chromium-bidi/lib/cjs/protocol/protocol.js';
+
+import {ProtocolError, TimeoutError} from '../common/Errors.js';
+import {PuppeteerURL} from '../common/util.js';
+
+import {BidiDeserializer} from './Deserializer.js';
+
+/**
+ * @internal
+ */
+export function createEvaluationError(
+  details: Bidi.Script.ExceptionDetails
+): unknown {
+  if (details.exception.type !== 'error') {
+    return BidiDeserializer.deserialize(details.exception);
+  }
+  const [name = '', ...parts] = details.text.split(': ');
+  const message = parts.join(': ');
+  const error = new Error(message);
+  error.name = name;
+
+  // The first line is this function which we ignore.
+  const stackLines = [];
+  if (details.stackTrace && stackLines.length < Error.stackTraceLimit) {
+    for (const frame of details.stackTrace.callFrames.reverse()) {
+      if (
+        PuppeteerURL.isPuppeteerURL(frame.url) &&
+        frame.url !== PuppeteerURL.INTERNAL_URL
+      ) {
+        const url = PuppeteerURL.parse(frame.url);
+        stackLines.unshift(
+          `    at ${frame.functionName || url.functionName} (${
+            url.functionName
+          } at ${url.siteString}, <anonymous>:${frame.lineNumber}:${
+            frame.columnNumber
+          })`
+        );
+      } else {
+        stackLines.push(
+          `    at ${frame.functionName || '<anonymous>'} (${frame.url}:${
+            frame.lineNumber
+          }:${frame.columnNumber})`
+        );
+      }
+      if (stackLines.length >= Error.stackTraceLimit) {
+        break;
+      }
+    }
+  }
+
+  error.stack = [details.text, ...stackLines].join('\n');
+  return error;
+}
+
+/**
+ * @internal
+ */
+export function rewriteNavigationError(
+  message: string,
+  ms: number
+): (error: unknown) => never {
+  return error => {
+    if (error instanceof ProtocolError) {
+      error.message += ` at ${message}`;
+    } else if (error instanceof TimeoutError) {
+      error.message = `Navigation timeout of ${ms} ms exceeded`;
+    }
+    throw error;
+  };
+}