chrome-devtools-frontend 1.0.1615539 → 1.0.1616061

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

@@ -152,6 +152,10 @@ export class TargetManager
     await this.#initializeDeferred.valueOrThrow();
   }
 
+  addToIgnoreTarget(targetId: string): void {
+    this.#ignoredTargets.add(targetId);
+  }
+
   getChildTargets(target: CdpTarget): ReadonlySet<CdpTarget> {
     return target._childTargets();
   }
@@ -172,6 +176,10 @@ export class TargetManager
     return this.#attachedTargetsByTargetId;
   }
 
+  getDiscoveredTargetInfos(): ReadonlyMap<string, Protocol.Target.TargetInfo> {
+    return this.#discoveredTargetsByTargetId;
+  }
+
   #setupAttachmentListeners(session: CDPSession | Connection): void {
     const listener = (event: Protocol.Target.AttachedToTargetEvent) => {
       void this.#onAttachedToTarget(session, event);
@@ -256,6 +264,7 @@ export class TargetManager
     const targetInfo = this.#discoveredTargetsByTargetId.get(event.targetId);
     this.#discoveredTargetsByTargetId.delete(event.targetId);
     this.#finishInitializationIfReady(event.targetId);
+
     if (targetInfo?.type === 'service_worker') {
       // Special case for service workers: report TargetGone event when
       // the worker is destroyed.
@@ -333,7 +342,11 @@ export class TargetManager
     // CDP.
     if (targetInfo.type === 'service_worker') {
       await this.#silentDetach(session, parentSession);
-      if (this.#attachedTargetsByTargetId.has(targetInfo.targetId)) {
+      if (
+        this.#attachedTargetsByTargetId.has(targetInfo.targetId) ||
+        this.#ignoredTargets.has(targetInfo.targetId) ||
+        !this.#discoveredTargetsByTargetId.has(targetInfo.targetId)
+      ) {
         return;
       }
       const target = this.#targetFactory(targetInfo);

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

@@ -0,0 +1,441 @@
+/**
+ * @license
+ * Copyright 2026 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {Protocol} from 'devtools-protocol';
+
+import type {CDPSession} from '../api/CDPSession.js';
+import type {ElementHandle} from '../api/ElementHandle.js';
+import type {Frame} from '../api/Frame.js';
+import type {ConsoleMessageLocation} from '../common/ConsoleMessage.js';
+import {EventEmitter} from '../common/EventEmitter.js';
+import {debugError} from '../common/util.js';
+
+import type {CdpFrame} from './Frame.js';
+import type {FrameManager} from './FrameManager.js';
+import {FrameManagerEvent} from './FrameManagerEvents.js';
+import {MAIN_WORLD} from './IsolatedWorlds.js';
+
+/**
+ * Tool annotations
+ *
+ * @public
+ */
+export interface WebMCPAnnotation {
+  /**
+   * A hint indicating that the tool does not modify any state.
+   */
+  readOnly?: boolean;
+  /**
+   * If the declarative tool was declared with the autosubmit attribute.
+   */
+  autosubmit?: boolean;
+}
+
+/**
+ * Represents the status of a tool invocation.
+ *
+ * @public
+ */
+export type WebMCPInvocationStatus = 'Completed' | 'Canceled' | 'Error';
+
+interface ProtocolWebMCPTool {
+  name: string;
+  description: string;
+  inputSchema?: object;
+  annotations?: WebMCPAnnotation;
+  frameId: string;
+  backendNodeId?: number;
+  stackTrace?: Protocol.Runtime.StackTrace;
+}
+
+interface ProtocolWebMCPToolsAddedEvent {
+  tools: ProtocolWebMCPTool[];
+}
+
+interface ProtocolWebMCPToolsRemovedEvent {
+  tools: ProtocolWebMCPTool[];
+}
+
+interface ProtocolWebMCPToolInvokedEvent {
+  toolName: string;
+  frameId: string;
+  invocationId: string;
+  input: string;
+}
+
+interface ProtocolWebMCPToolRespondedEvent {
+  invocationId: string;
+  status: WebMCPInvocationStatus;
+  output?: any;
+  errorText?: string;
+  exception?: Protocol.Runtime.RemoteObject;
+}
+
+/**
+ * Represents a registered WebMCP tool available on the page.
+ *
+ * @public
+ */
+export class WebMCPTool extends EventEmitter<{
+  /** Emitted when invocation starts. */
+  toolinvoked: WebMCPToolCall;
+}> {
+  #webmcp: WebMCP;
+  #backendNodeId?: number;
+  #formElement?: ElementHandle<HTMLFormElement>;
+
+  /**
+   * Tool name.
+   */
+  name: string;
+  /**
+   * Tool description.
+   */
+  description: string;
+  /**
+   * Schema for the tool's input parameters.
+   */
+  inputSchema?: object;
+  /**
+   * Optional annotations for the tool.
+   */
+  annotations?: WebMCPAnnotation;
+  /**
+   * Frame the tool was defined for.
+   */
+  frame: Frame;
+  /**
+   * Source location that defined the tool (if available).
+   */
+  location?: ConsoleMessageLocation;
+  /**
+   * @internal
+   */
+  rawStackTrace?: Protocol.Runtime.StackTrace;
+
+  /**
+   * @internal
+   */
+  constructor(webmcp: WebMCP, tool: ProtocolWebMCPTool, frame: Frame) {
+    super();
+    this.#webmcp = webmcp;
+    this.name = tool.name;
+    this.description = tool.description;
+    this.inputSchema = tool.inputSchema;
+    this.annotations = tool.annotations;
+    this.frame = frame;
+    this.#backendNodeId = tool.backendNodeId;
+    if (tool.stackTrace?.callFrames.length) {
+      this.location = {
+        url: tool.stackTrace.callFrames[0]!.url,
+        lineNumber: tool.stackTrace.callFrames[0]!.lineNumber,
+        columnNumber: tool.stackTrace.callFrames[0]!.columnNumber,
+      };
+    }
+    this.rawStackTrace = tool.stackTrace;
+  }
+
+  /**
+   * The corresponding ElementHandle when tool was registered via a form.
+   */
+  get formElement(): Promise<ElementHandle<HTMLFormElement> | undefined> {
+    return (async () => {
+      if (this.#formElement && !this.#formElement.disposed) {
+        return this.#formElement;
+      }
+      if (!this.#backendNodeId) {
+        return undefined;
+      }
+      this.#formElement = (await (this.frame as CdpFrame).worlds[
+        MAIN_WORLD
+      ].adoptBackendNode(
+        this.#backendNodeId,
+      )) as ElementHandle<HTMLFormElement>;
+      return this.#formElement;
+    })();
+  }
+
+  /**
+   * Executes tool with input parameters, matching tool's `inputSchema`.
+   */
+  async execute(input: object = {}): Promise<WebMCPToolCallResult> {
+    const {invocationId} = await this.#webmcp.invokeTool(this, input);
+    return await new Promise<WebMCPToolCallResult>(resolve => {
+      const handler = (event: WebMCPToolCallResult) => {
+        if (event.id === invocationId) {
+          this.#webmcp.off('toolresponded', handler);
+          resolve(event);
+        }
+      };
+      this.#webmcp.on('toolresponded', handler);
+    });
+  }
+}
+
+/**
+ * @public
+ */
+export interface WebMCPToolsAddedEvent {
+  /**
+   * Array of tools that were added.
+   */
+  tools: WebMCPTool[];
+}
+
+/**
+ * @public
+ */
+export interface WebMCPToolsRemovedEvent {
+  /**
+   * Array of tools that were removed.
+   */
+  tools: WebMCPTool[];
+}
+
+/**
+ * @public
+ */
+export class WebMCPToolCall {
+  /**
+   * Tool invocation identifier.
+   */
+  id: string;
+  /**
+   * Tool that was called.
+   */
+  tool: WebMCPTool;
+  /**
+   * The input parameters used for the call.
+   */
+  input: object;
+
+  /**
+   * @internal
+   */
+  constructor(invocationId: string, tool: WebMCPTool, input: string) {
+    this.id = invocationId;
+    this.tool = tool;
+    try {
+      this.input = JSON.parse(input);
+    } catch (error) {
+      this.input = {};
+      debugError(error);
+    }
+  }
+}
+
+/**
+ * @public
+ */
+export interface WebMCPToolCallResult {
+  /**
+   * Tool invocation identifier.
+   */
+  id: string;
+  /**
+   * The corresponding tool call if available.
+   */
+  call?: WebMCPToolCall;
+  /**
+   * Status of the invocation.
+   */
+  status: WebMCPInvocationStatus;
+  /**
+   * Output or error delivered as delivered to the agent. Missing if `status` is anything
+   * other than Completed.
+   */
+  output?: any;
+  /**
+   * Error text.
+   */
+  errorText?: string;
+  /**
+   * The exception object, if the javascript tool threw an error.
+   */
+  exception?: Protocol.Runtime.RemoteObject;
+}
+
+/**
+ * The experimental WebMCP class provides an API for the WebMCP API.
+ *
+ * See the
+ * {@link https://pptr.dev/guides/webmcp|WebMCP guide}
+ * for more details.
+ *
+ * @example
+ *
+ * ```ts
+ * await page.goto('https://www.example.com');
+ * const tools = page.webmcp.tools();
+ * for (const tool of tools) {
+ *   console.log(`Tool found: ${tool.name} - ${tool.description}`);
+ * }
+ * ```
+ *
+ * @experimental
+ * @public
+ */
+export class WebMCP extends EventEmitter<{
+  /** Emitted when tools are added. */
+  toolsadded: WebMCPToolsAddedEvent;
+  /** Emitted when tools are removed. */
+  toolsremoved: WebMCPToolsRemovedEvent;
+  /** Emitted when a tool invocation starts. */
+  toolinvoked: WebMCPToolCall;
+  /** Emitted when a tool invocation completes or fails. */
+  toolresponded: WebMCPToolCallResult;
+}> {
+  #client: CDPSession;
+  #frameManager: FrameManager;
+  #tools = new Map<string, Map<string, WebMCPTool>>();
+  #pendingCalls = new Map<string, WebMCPToolCall>();
+
+  #onToolsAdded = (event: ProtocolWebMCPToolsAddedEvent) => {
+    const tools: WebMCPTool[] = [];
+    for (const tool of event.tools) {
+      const frame = this.#frameManager.frame(tool.frameId);
+      if (!frame) {
+        continue;
+      }
+
+      const frameTools = this.#tools.get(tool.frameId) ?? new Map();
+      if (!this.#tools.has(tool.frameId)) {
+        this.#tools.set(tool.frameId, frameTools);
+      }
+
+      const addedTool = new WebMCPTool(this, tool, frame);
+      frameTools.set(tool.name, addedTool);
+      tools.push(addedTool);
+    }
+
+    this.emit('toolsadded', {tools});
+  };
+
+  #onToolsRemoved = (event: ProtocolWebMCPToolsRemovedEvent) => {
+    const tools: WebMCPTool[] = [];
+    event.tools.forEach(tool => {
+      const removedTool = this.#tools.get(tool.frameId)?.get(tool.name);
+      if (removedTool) {
+        tools.push(removedTool);
+      }
+      this.#tools.get(tool.frameId)?.delete(tool.name);
+    });
+    this.emit('toolsremoved', {tools});
+  };
+
+  #onToolInvoked = (event: ProtocolWebMCPToolInvokedEvent) => {
+    const tool = this.#tools.get(event.frameId)?.get(event.toolName);
+    if (!tool) {
+      return;
+    }
+    const call = new WebMCPToolCall(event.invocationId, tool, event.input);
+    this.#pendingCalls.set(call.id, call);
+    tool.emit('toolinvoked', call);
+    this.emit('toolinvoked', call);
+  };
+
+  #onToolResponded = (event: ProtocolWebMCPToolRespondedEvent) => {
+    const call = this.#pendingCalls.get(event.invocationId);
+    if (call) {
+      this.#pendingCalls.delete(event.invocationId);
+    }
+    const response: WebMCPToolCallResult = {
+      id: event.invocationId,
+      call: call,
+      status: event.status,
+      output: event.output,
+      errorText: event.errorText,
+      exception: event.exception,
+    };
+    this.emit('toolresponded', response);
+  };
+
+  #onFrameNavigated = (frame: Frame) => {
+    this.#pendingCalls.clear();
+    const frameTools = this.#tools.get(frame._id);
+    if (!frameTools) {
+      return;
+    }
+    const tools = Array.from(frameTools.values());
+    this.#tools.delete(frame._id);
+    if (tools.length) {
+      this.emit('toolsremoved', {tools});
+    }
+  };
+
+  /**
+   * @internal
+   */
+  constructor(client: CDPSession, frameManager: FrameManager) {
+    super();
+    this.#client = client;
+    this.#frameManager = frameManager;
+    this.#frameManager.on(
+      FrameManagerEvent.FrameNavigated,
+      this.#onFrameNavigated,
+    );
+    this.#bindListeners();
+  }
+
+  /**
+   * @internal
+   */
+  async initialize(): Promise<void> {
+    // @ts-expect-error WebMCP is not yet in the Protocol types.
+    return await this.#client.send('WebMCP.enable').catch(debugError);
+  }
+
+  /**
+   * @internal
+   */
+  async invokeTool(
+    tool: WebMCPTool,
+    input: object,
+  ): Promise<{invocationId: string}> {
+    // @ts-expect-error WebMCP is not yet in the Protocol types.
+    return await this.#client.send('WebMCP.invokeTool', {
+      frameId: tool.frame._id,
+      toolName: tool.name,
+      input,
+    });
+  }
+
+  /**
+   * Gets all WebMCP tools defined by the page.
+   */
+  tools(): WebMCPTool[] {
+    return Array.from(this.#tools.values()).flatMap(toolMap => {
+      return Array.from(toolMap.values());
+    });
+  }
+
+  #bindListeners(): void {
+    // @ts-expect-error WebMCP is not yet in the Protocol types.
+    this.#client.on('WebMCP.toolsAdded', this.#onToolsAdded);
+    // @ts-expect-error WebMCP is not yet in the Protocol types.
+    this.#client.on('WebMCP.toolsRemoved', this.#onToolsRemoved);
+    // @ts-expect-error WebMCP is not yet in the Protocol types.
+    this.#client.on('WebMCP.toolInvoked', this.#onToolInvoked);
+    // @ts-expect-error WebMCP is not yet in the Protocol types.
+    this.#client.on('WebMCP.toolResponded', this.#onToolResponded);
+  }
+
+  /**
+   * @internal
+   */
+  updateClient(client: CDPSession): void {
+    // @ts-expect-error WebMCP is not yet in the Protocol types.
+    this.#client.off('WebMCP.toolsAdded', this.#onToolsAdded);
+    // @ts-expect-error WebMCP is not yet in the Protocol types.
+    this.#client.off('WebMCP.toolsRemoved', this.#onToolsRemoved);
+    // @ts-expect-error WebMCP is not yet in the Protocol types.
+    this.#client.off('WebMCP.toolInvoked', this.#onToolInvoked);
+    // @ts-expect-error WebMCP is not yet in the Protocol types.
+    this.#client.off('WebMCP.toolResponded', this.#onToolResponded);
+    this.#client = client;
+    this.#bindListeners();
+  }
+}

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

@@ -8,21 +8,20 @@ import type {Protocol} from 'devtools-protocol';
 import {CDPSessionEvent, type CDPSession} from '../api/CDPSession.js';
 import type {Realm} from '../api/Realm.js';
 import {TargetType} from '../api/Target.js';
-import {WebWorker} from '../api/WebWorker.js';
+import {
+  WebWorker,
+  WebWorkerEvent,
+  type WebWorkerEvents,
+} from '../api/WebWorker.js';
+import {EventEmitter} from '../common/EventEmitter.js';
 import {TimeoutSettings} from '../common/TimeoutSettings.js';
 import {debugError} from '../common/util.js';
 
 import {ExecutionContext} from './ExecutionContext.js';
 import {IsolatedWorld} from './IsolatedWorld.js';
+import {MAIN_WORLD} from './IsolatedWorlds.js';
 import type {NetworkManager} from './NetworkManager.js';
-
-/**
- * @internal
- */
-export type ConsoleAPICalledCallback = (
-  world: IsolatedWorld,
-  event: Protocol.Runtime.ConsoleAPICalledEvent,
-) => void;
+import {createConsoleMessage} from './utils.js';
 
 /**
  * @internal
@@ -39,13 +38,17 @@ export class CdpWebWorker extends WebWorker {
   #client: CDPSession;
   readonly #id: string;
   readonly #targetType: TargetType;
+  readonly #emitter: EventEmitter<WebWorkerEvents>;
+
+  get internalEmitter(): EventEmitter<WebWorkerEvents> {
+    return this.#emitter;
+  }
 
   constructor(
     client: CDPSession,
     url: string,
     targetId: string,
     targetType: TargetType,
-    consoleAPICalled: ConsoleAPICalledCallback,
     exceptionThrown: ExceptionThrownCallback,
     networkManager?: NetworkManager,
   ) {
@@ -53,7 +56,8 @@ export class CdpWebWorker extends WebWorker {
     this.#id = targetId;
     this.#client = client;
     this.#targetType = targetType;
-    this.#world = new IsolatedWorld(this, new TimeoutSettings());
+    this.#world = new IsolatedWorld(this, new TimeoutSettings(), MAIN_WORLD);
+    this.#emitter = new EventEmitter<WebWorkerEvents>();
 
     this.#client.once('Runtime.executionContextCreated', async event => {
       this.#world.setContext(
@@ -62,7 +66,29 @@ export class CdpWebWorker extends WebWorker {
     });
     this.#world.emitter.on('consoleapicalled', async event => {
       try {
-        return consoleAPICalled(this.#world, event);
+        const values = event.args.map(arg => {
+          return this.#world.createCdpHandle(arg);
+        });
+
+        const noInternalListeners =
+          this.#emitter.listenerCount(WebWorkerEvent.Console) === 0;
+        const noWorkerListeners =
+          this.listenerCount(WebWorkerEvent.Console) === 0;
+
+        if (noInternalListeners && noWorkerListeners) {
+          // 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;
+        }
+
+        const consoleMessages = createConsoleMessage(event, values, this.#id);
+        this.#emitter.emit(WebWorkerEvent.Console, consoleMessages);
+        if (!noWorkerListeners) {
+          this.emit(WebWorkerEvent.Console, consoleMessages);
+        }
       } catch (err) {
         debugError(err);
       }

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

@@ -39,5 +39,6 @@ export * from './Target.js';
 export * from './TargetManager.js';
 export * from './TargetManageEvents.js';
 export * from './Tracing.js';
+export * from './WebMCP.js';
 export * from './utils.js';
 export * from './WebWorker.js';

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

@@ -7,9 +7,49 @@
 import type {Protocol} from 'devtools-protocol';
 
 import type {JSHandle} from '../api/JSHandle.js';
+import {
+  ConsoleMessage,
+  type ConsoleMessageType,
+} from '../common/ConsoleMessage.js';
 import {PuppeteerURL, evaluationString} from '../common/util.js';
 import {assert} from '../util/assert.js';
 
+/**
+ * @internal
+ */
+export function createConsoleMessage(
+  event: Protocol.Runtime.ConsoleAPICalledEvent,
+  values: JSHandle[],
+  targetId?: string,
+): ConsoleMessage {
+  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,
+      });
+    }
+  }
+
+  return new ConsoleMessage(
+    convertConsoleMessageLevel(event.type),
+    textTokens.join(' '),
+    values,
+    stackTraceLocations,
+    undefined,
+    event.stackTrace,
+    targetId,
+  );
+}
+
 /**
  * @internal
  */
@@ -269,3 +309,15 @@ export const CDP_BINDING_PREFIX = 'puppeteer_';
 export function pageBindingInitString(type: string, name: string): string {
   return evaluationString(addPageBinding, type, name, CDP_BINDING_PREFIX);
 }
+
+/**
+ * @internal
+ */
+export function convertConsoleMessageLevel(method: string): ConsoleMessageType {
+  switch (method) {
+    case 'warning':
+      return 'warn';
+    default:
+      return method as ConsoleMessageType;
+  }
+}

package/front_end/third_party/puppeteer/package/src/common/ConnectOptions.ts

@@ -78,6 +78,13 @@ export interface ConnectOptions {
    * @defaultValue `true`
    */
   networkEnabled?: boolean;
+  /**
+   * Experimental setting to disable monitoring issue events by default.
+   *
+   * @experimental
+   * @defaultValue `true`
+   */
+  issuesEnabled?: boolean;
   /**
    * Sets the viewport for each page.
    *

package/front_end/third_party/puppeteer/package/src/common/types.ts

@@ -9,8 +9,6 @@ import type {ParseSelector} from 'typed-query-selector/parser.js';
 import type {ElementHandle} from '../api/ElementHandle.js';
 import type {JSHandle} from '../api/JSHandle.js';
 
-import type {LazyArg} from './LazyArg.js';
-
 /**
  * @public
  */
@@ -77,18 +75,6 @@ export type HandleOr<T> = HandleFor<T> | JSHandle<T> | T;
  */
 export type FlattenHandle<T> = T extends HandleOr<infer U> ? U : never;
 
-/**
- * @internal
- */
-export type FlattenLazyArg<T> = T extends LazyArg<infer U> ? U : T;
-
-/**
- * @internal
- */
-export type InnerLazyParams<T extends unknown[]> = {
-  [K in keyof T]: FlattenLazyArg<T[K]>;
-};
-
 /**
  * @public
  */