chrome-devtools-frontend 1.0.1615539 → 1.0.1616061

package/front_end/third_party/puppeteer/package/src/cdp/Extension.ts

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * Copyright 2026 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type {Page, Target, WebWorker} from '../api/api.js';
+import {Extension} from '../api/api.js';
+import {debugError} from '../common/util.js';
+import {isErrorLike} from '../util/ErrorLike.js';
+
+import type {CdpBrowser} from './Browser.js';
+import {isTargetClosedError} from './Connection.js';
+
+export class CdpExtension extends Extension {
+  // needed to access the CDPSession to trigger an extension action.
+  #browser: CdpBrowser;
+
+  /*
+   * @internal
+   */
+  constructor(id: string, version: string, name: string, browser: CdpBrowser) {
+    super(id, version, name);
+    this.#browser = browser;
+  }
+
+  async workers(): Promise<WebWorker[]> {
+    const targets = this.#browser.targets();
+
+    const extensionWorkers = targets.filter((target: Target) => {
+      const targetUrl = target.url();
+      return (
+        target.type() === 'service_worker' &&
+        targetUrl.startsWith('chrome-extension://' + this.id)
+      );
+    });
+
+    const workers: WebWorker[] = [];
+    for (const target of extensionWorkers) {
+      try {
+        const worker = await target.worker();
+
+        if (worker) {
+          workers.push(worker);
+        }
+      } catch (err) {
+        if (this.#canIgnoreError(err)) {
+          debugError(err);
+          continue;
+        }
+        throw err;
+      }
+    }
+
+    return workers;
+  }
+
+  async pages(): Promise<Page[]> {
+    const targets = this.#browser.targets();
+
+    const extensionPages = targets.filter((target: Target) => {
+      const targetUrl = target.url();
+      return (
+        (target.type() === 'page' || target.type() === 'background_page') &&
+        targetUrl.startsWith('chrome-extension://' + this.id)
+      );
+    });
+
+    const pages = await Promise.all(
+      extensionPages.map(async target => {
+        try {
+          return await target.asPage();
+        } catch (err) {
+          if (this.#canIgnoreError(err)) {
+            debugError(err);
+            return null;
+          }
+          throw err;
+        }
+      }),
+    );
+
+    return pages.filter((page): page is Page => {
+      return page !== null;
+    });
+  }
+
+  async triggerAction(page: Page): Promise<void> {
+    await this.#browser._connection.send('Extensions.triggerAction', {
+      id: this.id,
+      targetId: page._tabId,
+    });
+  }
+
+  #canIgnoreError(error: unknown): boolean {
+    return (
+      isErrorLike(error) &&
+      (isTargetClosedError(error) ||
+        error.message.includes('No target with given id found'))
+    );
+  }
+}

package/front_end/third_party/puppeteer/package/src/cdp/Frame.ts

@@ -15,6 +15,7 @@ import type {HTTPResponse} from '../api/HTTPResponse.js';
 import type {WaitTimeoutOptions} from '../api/Page.js';
 import {UnsupportedOperation} from '../common/Errors.js';
 import {debugError} from '../common/util.js';
+import type {Realm} from '../puppeteer-core.js';
 import {Deferred} from '../util/Deferred.js';
 import {disposeSymbol} from '../util/disposable.js';
 import {isErrorLike} from '../util/ErrorLike.js';
@@ -52,6 +53,7 @@ export class CdpFrame extends Frame {
   override accessibility: Accessibility;
 
   worlds: IsolatedWorldChart;
+  extensionWorlds: Record<string, IsolatedWorld> = {};
 
   constructor(
     frameManager: FrameManager,
@@ -69,10 +71,15 @@ export class CdpFrame extends Frame {
 
     this._loaderId = '';
     this.worlds = {
-      [MAIN_WORLD]: new IsolatedWorld(this, this._frameManager.timeoutSettings),
+      [MAIN_WORLD]: new IsolatedWorld(
+        this,
+        this._frameManager.timeoutSettings,
+        MAIN_WORLD,
+      ),
       [PUPPETEER_WORLD]: new IsolatedWorld(
         this,
         this._frameManager.timeoutSettings,
+        PUPPETEER_WORLD,
       ),
     };
 
@@ -84,30 +91,23 @@ export class CdpFrame extends Frame {
       this._onLoadingStopped();
     });
 
-    this.worlds[MAIN_WORLD].emitter.on(
-      'consoleapicalled',
-      this.#onMainWorldConsoleApiCalled.bind(this),
-    );
-    this.worlds[MAIN_WORLD].emitter.on(
-      'bindingcalled',
-      this.#onMainWorldBindingCalled.bind(this),
-    );
+    this.registerWorldListeners(this.worlds[MAIN_WORLD]);
   }
 
-  #onMainWorldConsoleApiCalled(
-    event: Protocol.Runtime.ConsoleAPICalledEvent,
-  ): void {
-    this._frameManager.emit(FrameManagerEvent.ConsoleApiCalled, [
-      this.worlds[MAIN_WORLD],
-      event,
-    ]);
-  }
+  /**
+   * @internal
+   */
+  registerWorldListeners(world: IsolatedWorld): void {
+    world.emitter.on('consoleapicalled', event => {
+      this._frameManager.emit(FrameManagerEvent.ConsoleApiCalled, [
+        world,
+        event,
+      ]);
+    });
 
-  #onMainWorldBindingCalled(event: Protocol.Runtime.BindingCalledEvent) {
-    this._frameManager.emit(FrameManagerEvent.BindingCalled, [
-      this.worlds[MAIN_WORLD],
-      event,
-    ]);
+    world.emitter.on('bindingcalled', event => {
+      this._frameManager.emit(FrameManagerEvent.BindingCalled, [world, event]);
+    });
   }
 
   /**
@@ -417,6 +417,9 @@ export class CdpFrame extends Frame {
     this.#detached = true;
     this.worlds[MAIN_WORLD][disposeSymbol]();
     this.worlds[PUPPETEER_WORLD][disposeSymbol]();
+    for (const extensionWorld of Object.values(this.extensionWorlds)) {
+      extensionWorld[disposeSymbol]();
+    }
   }
 
   exposeFunction(): never {
@@ -435,6 +438,13 @@ export class CdpFrame extends Frame {
       .mainRealm()
       .adoptBackendNode(backendNodeId)) as ElementHandle<HTMLIFrameElement>;
   }
+
+  /**
+   * @public
+   */
+  override extensionRealms(): Realm[] {
+    return Object.values(this.extensionWorlds);
+  }
 }
 
 /**

package/front_end/third_party/puppeteer/package/src/cdp/FrameManager.ts

@@ -8,7 +8,7 @@ import type {Protocol} from 'devtools-protocol';
 
 import {type CDPSession, CDPSessionEvent} from '../api/CDPSession.js';
 import {FrameEvent} from '../api/Frame.js';
-import type {NewDocumentScriptEvaluation} from '../api/Page.js';
+import {PageEvent, type NewDocumentScriptEvaluation} from '../api/Page.js';
 import {EventEmitter} from '../common/EventEmitter.js';
 import type {TimeoutSettings} from '../common/TimeoutSettings.js';
 import {debugError, PuppeteerURL, UTILITY_WORLD_NAME} from '../common/util.js';
@@ -18,6 +18,7 @@ import {disposeSymbol} from '../util/disposable.js';
 import {isErrorLike} from '../util/ErrorLike.js';
 
 import type {Binding} from './Binding.js';
+import {CdpIssue} from './CdpIssue.js';
 import {CdpPreloadScript} from './CdpPreloadScript.js';
 import type {CdpCDPSession} from './CdpSession.js';
 import {isTargetClosedError} from './Connection.js';
@@ -27,14 +28,14 @@ import {CdpFrame} from './Frame.js';
 import type {FrameManagerEvents} from './FrameManagerEvents.js';
 import {FrameManagerEvent} from './FrameManagerEvents.js';
 import {FrameTree} from './FrameTree.js';
-import type {IsolatedWorld} from './IsolatedWorld.js';
+import {IsolatedWorld} from './IsolatedWorld.js';
 import {MAIN_WORLD, PUPPETEER_WORLD} from './IsolatedWorlds.js';
 import {NetworkManager} from './NetworkManager.js';
 import type {CdpPage} from './Page.js';
 import type {CdpTarget} from './Target.js';
 
 const TIME_FOR_WAITING_FOR_SWAP = 100; // ms.
-
+const CHROME_EXTENSION_PREFIX = 'chrome-extension://';
 /**
  * A frame manager manages the frames for a given {@link Page | page}.
  *
@@ -201,6 +202,9 @@ export class FrameManager extends EventEmitter<FrameManagerEvents> {
       await this.#frameTreeHandled?.valueOrThrow();
       this.#onLifecycleEvent(event);
     });
+    session.on('Audits.issueAdded', event => {
+      this.#page.emit(PageEvent.Issue, new CdpIssue(event.issue));
+    });
   }
 
   async initialize(client: CDPSession, frame?: CdpFrame | null): Promise<void> {
@@ -231,6 +235,7 @@ export class FrameManager extends EventEmitter<FrameManagerEvents> {
         ...(frame ? Array.from(this.#bindings.values()) : []).map(binding => {
           return frame?.addExposedFunctionBinding(binding);
         }),
+        this.#page.browser().isIssuesEnabled() && client.send('Audits.enable'),
       ]);
     } catch (error) {
       this.#frameTreeHandled?.resolve();
@@ -536,11 +541,29 @@ export class FrameManager extends EventEmitter<FrameManagerEvents> {
     }
   }
 
+  #isExtensionOrigin(origin: string) {
+    return origin.startsWith(CHROME_EXTENSION_PREFIX);
+  }
+
+  #extractExtensionId(origin: string): string | null {
+    if (!origin || !this.#isExtensionOrigin(origin)) {
+      return null;
+    }
+
+    const pathPart = origin.substring(CHROME_EXTENSION_PREFIX.length);
+    const slashIndex = pathPart.indexOf('/');
+
+    // if there's no / it means that pathPart is now the extensionId, otherwise
+    // we take everything until the first /
+    return slashIndex === -1 ? pathPart : pathPart.substring(0, slashIndex);
+  }
+
   #onExecutionContextCreated(
     contextPayload: Protocol.Runtime.ExecutionContextDescription,
     session: CDPSession,
   ): void {
     const auxData = contextPayload.auxData as {frameId?: string} | undefined;
+    const origin = contextPayload.origin;
     const frameId = auxData && auxData.frameId;
     const frame = typeof frameId === 'string' ? this.frame(frameId) : undefined;
     let world: IsolatedWorld | undefined;
@@ -556,8 +579,26 @@ export class FrameManager extends EventEmitter<FrameManagerEvents> {
         // connections so we might end up creating multiple isolated worlds.
         // We can use either.
         world = frame.worlds[PUPPETEER_WORLD];
+      } else if (this.#isExtensionOrigin(origin)) {
+        const extId = this.#extractExtensionId(origin);
+
+        if (!extId) {
+          debugError('Error while parsing extension id');
+          return;
+        }
+
+        if (frame.extensionWorlds[extId]) {
+          world = frame.extensionWorlds[extId];
+        } else {
+          world = new IsolatedWorld(frame, this.timeoutSettings, extId);
+          frame.extensionWorlds[extId] = world;
+          frame.registerWorldListeners(world);
+          world.origin = origin;
+          world.setWorldId(extId);
+        }
       }
     }
+
     // If there is no world, the context is not meant to be handled by us.
     if (!world) {
       return;

package/front_end/third_party/puppeteer/package/src/cdp/IsolatedWorld.ts

@@ -9,6 +9,7 @@ import type {Protocol} from 'devtools-protocol';
 import {firstValueFrom, map, raceWith} from '../../third_party/rxjs/rxjs.js';
 import type {CDPSession} from '../api/CDPSession.js';
 import type {ElementHandle} from '../api/ElementHandle.js';
+import type {Extension} from '../api/Extension.js';
 import type {JSHandle} from '../api/JSHandle.js';
 import {Realm} from '../api/Realm.js';
 import {EventEmitter} from '../common/EventEmitter.js';
@@ -24,9 +25,10 @@ import {disposeSymbol} from '../util/disposable.js';
 import {CdpElementHandle} from './ElementHandle.js';
 import type {ExecutionContext} from './ExecutionContext.js';
 import type {CdpFrame} from './Frame.js';
-import type {MAIN_WORLD, PUPPETEER_WORLD} from './IsolatedWorlds.js';
+import type {PUPPETEER_WORLD} from './IsolatedWorlds.js';
+import {MAIN_WORLD} from './IsolatedWorlds.js';
 import {CdpJSHandle} from './JSHandle.js';
-import type {CdpWebWorker} from './WebWorker.js';
+import {CdpWebWorker} from './WebWorker.js';
 
 /**
  * @internal
@@ -66,15 +68,19 @@ export type IsolatedWorldEmitter = EventEmitter<{
 export class IsolatedWorld extends Realm {
   #context?: ExecutionContext;
   #emitter: IsolatedWorldEmitter = new EventEmitter();
+  #worldId: string | symbol;
+  #origin?: string;
 
   readonly #frameOrWorker: CdpFrame | CdpWebWorker;
 
   constructor(
     frameOrWorker: CdpFrame | CdpWebWorker,
     timeoutSettings: TimeoutSettings,
+    worldId: string | symbol,
   ) {
     super(timeoutSettings);
     this.#frameOrWorker = frameOrWorker;
+    this.#worldId = worldId;
   }
 
   get environment(): CdpFrame | CdpWebWorker {
@@ -263,4 +269,36 @@ export class IsolatedWorld extends Realm {
     super[disposeSymbol]();
     this.#emitter.removeAllListeners();
   }
+
+  override get origin(): string | undefined {
+    return this.#origin;
+  }
+
+  set origin(origin: string) {
+    this.#origin = origin;
+  }
+
+  setWorldId(worldId: string | symbol): void {
+    this.#worldId = worldId;
+  }
+
+  async extension(): Promise<Extension | null> {
+    if (this.#frameOrWorker instanceof CdpWebWorker) {
+      throw new Error('Unable to get extension from Realm');
+    }
+
+    if (this.#worldId === MAIN_WORLD) {
+      return null;
+    }
+
+    if (typeof this.#worldId === 'string') {
+      const extensions = await this.#frameOrWorker._frameManager
+        .page()
+        .browser()
+        .extensions();
+      return extensions.get(this.#worldId) ?? null;
+    }
+
+    return null;
+  }
 }

package/front_end/third_party/puppeteer/package/src/cdp/Page.ts

@@ -13,6 +13,7 @@ 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 {Extension} from '../api/Extension.js';
 import type {Frame, WaitForOptions} from '../api/Frame.js';
 import type {HTTPResponse} from '../api/HTTPResponse.js';
 import type {JSHandle} from '../api/JSHandle.js';
@@ -32,10 +33,8 @@ import {
   type ScreenshotOptions,
   type WaitTimeoutOptions,
 } from '../api/Page.js';
-import {
-  ConsoleMessage,
-  type ConsoleMessageType,
-} from '../common/ConsoleMessage.js';
+import {WebWorker, WebWorkerEvent} from '../api/WebWorker.js';
+import {ConsoleMessage} from '../common/ConsoleMessage.js';
 import type {
   Cookie,
   DeleteCookiesRequest,
@@ -60,6 +59,7 @@ import {
 } from '../common/util.js';
 import type {Viewport} from '../common/Viewport.js';
 import {environment} from '../environment.js';
+import type {Realm} from '../index-browser.js';
 import {assert} from '../util/assert.js';
 import {Deferred} from '../util/Deferred.js';
 import {AsyncDisposableStack} from '../util/disposable.js';
@@ -86,21 +86,14 @@ import {TargetManagerEvent} from './TargetManageEvents.js';
 import type {TargetManager} from './TargetManager.js';
 import {Tracing} from './Tracing.js';
 import {
+  convertConsoleMessageLevel,
   createClientError,
+  createConsoleMessage,
   pageBindingInitString,
-  valueFromJSHandle,
 } from './utils.js';
+import {WebMCP} from './WebMCP.js';
 import {CdpWebWorker} from './WebWorker.js';
 
-function convertConsoleMessageLevel(method: string): ConsoleMessageType {
-  switch (method) {
-    case 'warning':
-      return 'warn';
-    default:
-      return method as ConsoleMessageType;
-  }
-}
-
 /**
  * @internal
  */
@@ -156,6 +149,7 @@ export class CdpPage extends Page {
   #frameManager: FrameManager;
   #emulationManager: EmulationManager;
   #tracing: Tracing;
+  #webmcp: WebMCP;
   #bindings = new Map<string, Binding>();
   #exposedFunctions = new Map<string, string>();
   #coverage: Coverage;
@@ -182,6 +176,7 @@ export class CdpPage extends Page {
     this.#frameManager = new FrameManager(client, this, this._timeoutSettings);
     this.#emulationManager = new EmulationManager(client);
     this.#tracing = new Tracing(client);
+    this.#webmcp = new WebMCP(client, this.#frameManager);
     this.#coverage = new Coverage(client);
     this.#viewport = null;
 
@@ -303,6 +298,7 @@ export class CdpPage extends Page {
     this.#touchscreen.updateClient(newSession);
     this.#emulationManager.updateClient(newSession);
     this.#tracing.updateClient(newSession);
+    this.#webmcp.updateClient(newSession);
     this.#coverage.updateClient(newSession);
     await this.#frameManager.swapFrameTree(newSession);
     this.#setupPrimaryTargetListeners();
@@ -368,11 +364,29 @@ export class CdpPage extends Page {
         session.target().url(),
         session.target()._targetId,
         session.target().type(),
-        this.#onConsoleAPI.bind(this),
         this.#handleException.bind(this),
         this.#frameManager.networkManager,
       );
       this.#workers.set(session.id(), worker);
+      worker.internalEmitter.on(WebWorkerEvent.Console, message => {
+        const noListenersForConsoleOnPage =
+          this.listenerCount(PageEvent.Console) === 0;
+        const noListenersForConsoleOnWorker =
+          worker.listenerCount(WebWorkerEvent.Console) === 0;
+
+        if (noListenersForConsoleOnPage && noListenersForConsoleOnWorker) {
+          // eslint-disable-next-line max-len -- The comment is long.
+          // eslint-disable-next-line @puppeteer/use-using -- These are not owned by this function.
+          for (const arg of message.args()) {
+            void arg.dispose().catch(debugError);
+          }
+          return;
+        }
+
+        if (!noListenersForConsoleOnPage) {
+          this.emit(PageEvent.Console, message);
+        }
+      });
       this.emit(PageEvent.WorkerCreated, worker);
     }
     session.on(CDPSessionEvent.Ready, this.#onAttachedToTarget);
@@ -384,6 +398,7 @@ export class CdpPage extends Page {
         this.#frameManager.initialize(this.#primaryTargetClient),
         this.#primaryTargetClient.send('Performance.enable'),
         this.#primaryTargetClient.send('Log.enable'),
+        this.#webmcp.initialize(),
       ]);
     } catch (err) {
       if (isErrorLike(err) && isTargetClosedError(err)) {
@@ -574,6 +589,10 @@ export class CdpPage extends Page {
     return this.#tracing;
   }
 
+  override get webmcp(): WebMCP {
+    return this.#webmcp;
+  }
+
   override frames(): Frame[] {
     return this.#frameManager.frames();
   }
@@ -905,32 +924,28 @@ export class CdpPage extends Page {
   #onConsoleAPI(
     world: IsolatedWorld,
     event: Protocol.Runtime.ConsoleAPICalledEvent,
+    values?: JSHandle[],
   ): void {
-    const values = event.args.map(arg => {
-      return world.createCdpHandle(arg);
-    });
-
-    if (!this.listenerCount(PageEvent.Console)) {
-      values.forEach(arg => {
-        return arg.dispose();
+    if (!values) {
+      values = event.args.map(arg => {
+        return world.createCdpHandle(arg);
       });
-      return;
-    }
-    const textTokens = [];
-    // eslint-disable-next-line max-len -- The comment is long.
-    // eslint-disable-next-line @puppeteer/use-using -- These are not owned by this function.
-    for (const arg of values) {
-      textTokens.push(valueFromJSHandle(arg));
     }
-    const stackTraceLocations = [];
-    if (event.stackTrace) {
-      for (const callFrame of event.stackTrace.callFrames) {
-        stackTraceLocations.push({
-          url: callFrame.url,
-          lineNumber: callFrame.lineNumber,
-          columnNumber: callFrame.columnNumber,
-        });
+
+    const hasPageConsoleListeners = this.listenerCount(PageEvent.Console) > 0;
+    const hasWorkerConsoleListeners =
+      world.environment instanceof WebWorker &&
+      world.environment.listenerCount(WebWorkerEvent.Console) > 0;
+
+    if (!hasPageConsoleListeners) {
+      if (!hasWorkerConsoleListeners) {
+        // eslint-disable-next-line max-len -- The comment is long.
+        // eslint-disable-next-line @puppeteer/use-using -- These are not owned by this function.
+        for (const value of values) {
+          void value.dispose().catch(debugError);
+        }
       }
+      return;
     }
 
     let targetId;
@@ -938,16 +953,7 @@ export class CdpPage extends Page {
       targetId = world.environment.client.target()._targetId;
     }
 
-    const message = new ConsoleMessage(
-      convertConsoleMessageLevel(event.type),
-      textTokens.join(' '),
-      values,
-      stackTraceLocations,
-      undefined,
-      event.stackTrace,
-      targetId,
-    );
-    this.emit(PageEvent.Console, message);
+    this.emit(PageEvent.Console, createConsoleMessage(event, values, targetId));
   }
 
   async #onBindingCalled(
@@ -1049,6 +1055,10 @@ export class CdpPage extends Page {
     await this.#primaryTargetClient.send('Page.setBypassCSP', {enabled});
   }
 
+  override async triggerExtensionAction(extension: Extension): Promise<void> {
+    return await extension.triggerAction(this);
+  }
+
   override async emulateMediaType(type?: string): Promise<void> {
     return await this.#emulationManager.emulateMediaType(type);
   }
@@ -1312,6 +1322,10 @@ export class CdpPage extends Page {
   override get bluetooth(): BluetoothEmulation {
     return this.#cdpBluetoothEmulation;
   }
+
+  override extensionRealms(): Realm[] {
+    return this.mainFrame().extensionRealms();
+  }
 }
 
 const supportedMetrics = new Set<string>([

package/front_end/third_party/puppeteer/package/src/cdp/Target.ts

@@ -42,6 +42,9 @@ export class CdpTarget extends Target {
   _initializedDeferred = Deferred.create<InitializationStatus>();
   _isClosedDeferred = Deferred.create<void>();
   _targetId: string;
+  _asPagePromise?: Promise<Page>;
+  /** @internal */
+  pagePromise?: Promise<Page>;
 
   /**
    * To initialize the target for use, call initialize.
@@ -70,13 +73,23 @@ export class CdpTarget extends Target {
   }
 
   override async asPage(): Promise<Page> {
-    const session = this._session();
-    if (!session) {
-      return await this.createCDPSession().then(client => {
+    if (this.pagePromise) {
+      const page = await this.pagePromise;
+      if (page) {
+        return page;
+      }
+    }
+    if (!this._asPagePromise) {
+      const session = this._session();
+      this._asPagePromise = (
+        session
+          ? Promise.resolve(session)
+          : this._sessionFactory()(/* isAutoAttachEmulated=*/ false)
+      ).then(client => {
         return CdpPage._create(client, this, null);
       });
     }
-    return await CdpPage._create(session, this, null);
+    return (await this._asPagePromise) ?? null;
   }
 
   _subtype(): string | undefined {
@@ -206,7 +219,6 @@ export class CdpTarget extends Target {
  */
 export class PageTarget extends CdpTarget {
   #defaultViewport?: Viewport;
-  protected pagePromise?: Promise<Page>;
 
   constructor(
     targetInfo: Protocol.Target.TargetInfo,
@@ -284,7 +296,6 @@ export class WorkerTarget extends CdpTarget {
   override async worker(): Promise<CdpWebWorker | null> {
     if (!this.#workerPromise) {
       const session = this._session();
-      // TODO(einbinder): Make workers send their console logs.
       this.#workerPromise = (
         session
           ? Promise.resolve(session)
@@ -295,7 +306,6 @@ export class WorkerTarget extends CdpTarget {
           this._getTargetInfo().url,
           this._targetId,
           this.type(),
-          () => {} /* consoleAPICalled */,
           () => {} /* exceptionThrown */,
           undefined /* networkManager */,
         );