chrome-devtools-mcp 0.8.1 → 0.10.0

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/host.js

@@ -2,11 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 import * as AidaClient from './AidaClient.js';
+import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
 import * as GdpClient from './GdpClient.js';
 import * as InspectorFrontendHost from './InspectorFrontendHost.js';
 import * as InspectorFrontendHostAPI from './InspectorFrontendHostAPI.js';
 import * as Platform from './Platform.js';
 import * as ResourceLoader from './ResourceLoader.js';
 import * as UserMetrics from './UserMetrics.js';
-export { AidaClient, GdpClient, InspectorFrontendHost, InspectorFrontendHostAPI, Platform, ResourceLoader, UserMetrics, };
+export { AidaClient, DispatchHttpRequestClient, GdpClient, InspectorFrontendHost, InspectorFrontendHostAPI, Platform, ResourceLoader, UserMetrics, };
 export const userMetrics = new UserMetrics.UserMetrics();

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/ArrayUtilities.js

@@ -18,7 +18,7 @@ export const removeElement = (array, element, firstOnly) => {
     array.length = index;
     return true;
 };
-function swap(array, i1, i2) {
+export function swap(array, i1, i2) {
     const temp = array[i1];
     array[i1] = array[i2];
     array[i2] = temp;

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/CDPConnection.js

@@ -0,0 +1,17 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+/**
+ * Keep this in sync with https://source.chromium.org/chromium/chromium/src/+/main:third_party/inspector_protocol/crdtp/dispatch.h.
+ */
+export var CDPErrorStatus;
+(function (CDPErrorStatus) {
+    CDPErrorStatus[CDPErrorStatus["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+    CDPErrorStatus[CDPErrorStatus["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+    CDPErrorStatus[CDPErrorStatus["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+    CDPErrorStatus[CDPErrorStatus["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+    CDPErrorStatus[CDPErrorStatus["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+    CDPErrorStatus[CDPErrorStatus["SERVER_ERROR"] = -32000] = "SERVER_ERROR";
+    CDPErrorStatus[CDPErrorStatus["SESSION_NOT_FOUND"] = -32001] = "SESSION_NOT_FOUND";
+    CDPErrorStatus[CDPErrorStatus["DEVTOOLS_STUB_ERROR"] = -32015] = "DEVTOOLS_STUB_ERROR";
+})(CDPErrorStatus || (CDPErrorStatus = {}));

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/ConnectionTransport.js

@@ -0,0 +1,12 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+let connectionFactory;
+export class ConnectionTransport {
+    static setFactory(factory) {
+        connectionFactory = factory;
+    }
+    static getFactory() {
+        return connectionFactory;
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/InspectorBackend.js

@@ -1,12 +1,10 @@
 // Copyright 2011 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+import * as InspectorBackendCommands from '../../generated/InspectorBackendCommands.js';
+import { CDPErrorStatus } from './CDPConnection.js';
+import { ConnectionTransport } from './ConnectionTransport.js';
 import { NodeURL } from './NodeURL.js';
-export const DevToolsStubErrorCode = -32015;
-// TODO(dgozman): we are not reporting generic errors in tests, but we should
-// instead report them and just have some expected errors in test expectations.
-const GenericErrorCode = -32000;
-const ConnectionClosedErrorCode = -32001;
 export const splitQualifiedName = (string) => {
     const [domain, eventName] = string.split('.');
     return [domain, eventName];
@@ -16,10 +14,16 @@ export const qualifyName = (domain, name) => {
 };
 export class InspectorBackend {
     agentPrototypes = new Map();
-    #initialized = false;
     #eventParameterNamesForDomain = new Map();
     typeMap = new Map();
     enumMap = new Map();
+    constructor() {
+        // Create the global here because registering commands will involve putting
+        // items onto the global.
+        // @ts-expect-error Global namespace instantiation
+        globalThis.Protocol ||= {};
+        InspectorBackendCommands.registerCommands(this);
+    }
     getOrCreateEventParameterNamesForDomain(domain) {
         let map = this.#eventParameterNamesForDomain.get(domain);
         if (!map) {
@@ -40,9 +44,6 @@ export class InspectorBackend {
     static reportProtocolWarning(error, messageObject) {
         console.warn(error + ': ' + JSON.stringify(messageObject));
     }
-    isInitialized() {
-        return this.#initialized;
-    }
     agentPrototype(domain) {
         let prototype = this.agentPrototypes.get(domain);
         if (!prototype) {
@@ -54,7 +55,6 @@ export class InspectorBackend {
     registerCommand(method, parameters, replyArgs, description) {
         const [domain, command] = splitQualifiedName(method);
         this.agentPrototype(domain).registerCommand(command, parameters, replyArgs, description);
-        this.#initialized = true;
     }
     registerEnum(type, values) {
         const [domain, name] = splitQualifiedName(type);
@@ -66,37 +66,14 @@ export class InspectorBackend {
         // @ts-expect-error globalThis global namespace pollution
         globalThis.Protocol[domain][name] = values;
         this.enumMap.set(type, values);
-        this.#initialized = true;
     }
     registerType(method, parameters) {
         this.typeMap.set(method, parameters);
-        this.#initialized = true;
     }
     registerEvent(eventName, params) {
         const domain = eventName.split('.')[0];
         const eventParameterNames = this.getOrCreateEventParameterNamesForDomain(domain);
         eventParameterNames.set(eventName, params);
-        this.#initialized = true;
-    }
-}
-let connectionFactory;
-export class Connection {
-    // on message from browser
-    setOnMessage(_onMessage) {
-    }
-    setOnDisconnect(_onDisconnect) {
-    }
-    // send raw CDP message to browser
-    sendRawMessage(_message) {
-    }
-    disconnect() {
-        throw new Error('not implemented');
-    }
-    static setFactory(factory) {
-        connectionFactory = factory;
-    }
-    static getFactory() {
-        return connectionFactory;
     }
 }
 export const test = {
@@ -136,6 +113,8 @@ export class SessionRouter {
     #pendingLongPollingMessageIds = new Set();
     #sessions = new Map();
     #pendingScripts = [];
+    #callbacks = new Map();
+    #observers = new Set();
     constructor(connection) {
         this.#connection = connection;
         test.deprecatedRunAfterPendingDispatches = this.deprecatedRunAfterPendingDispatches.bind(this);
@@ -146,45 +125,43 @@ export class SessionRouter {
             if (session) {
                 session.target.dispose(reason);
             }
+            this.#observers.forEach(observer => observer.onDisconnect(reason));
         });
     }
-    registerSession(target, sessionId, proxyConnection) {
-        // Only the Audits panel uses proxy connections. If it is ever possible to have multiple active at the
-        // same time, it should be tested thoroughly.
-        if (proxyConnection) {
-            for (const session of this.#sessions.values()) {
-                if (session.proxyConnection) {
-                    console.error('Multiple simultaneous proxy connections are currently unsupported');
-                    break;
-                }
-            }
-        }
-        this.#sessions.set(sessionId, { target, callbacks: new Map(), proxyConnection });
+    observe(observer) {
+        this.#observers.add(observer);
+    }
+    unobserve(observer) {
+        this.#observers.delete(observer);
+    }
+    registerSession(target, sessionId) {
+        this.#sessions.set(sessionId, { target });
     }
     unregisterSession(sessionId) {
         const session = this.#sessions.get(sessionId);
         if (!session) {
             return;
         }
-        for (const callback of session.callbacks.values()) {
-            SessionRouter.dispatchUnregisterSessionError(callback);
+        for (const { resolve, method, sessionId: callbackSessionId } of this.#callbacks.values()) {
+            if (sessionId !== callbackSessionId) {
+                continue;
+            }
+            resolve({
+                error: {
+                    message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
+                    code: CDPErrorStatus.SESSION_NOT_FOUND,
+                }
+            });
         }
         this.#sessions.delete(sessionId);
     }
-    getTargetBySessionId(sessionId) {
-        const session = this.#sessions.get(sessionId ? sessionId : '');
-        if (!session) {
-            return null;
-        }
-        return session.target;
-    }
     nextMessageId() {
         return this.#lastMessageId++;
     }
     connection() {
         return this.#connection;
     }
-    sendMessage(sessionId, domain, method, params, callback) {
+    send(method, params, sessionId) {
         const messageId = this.nextMessageId();
         const messageObject = {
             id: messageId,
@@ -200,23 +177,28 @@ export class SessionRouter {
             test.dumpProtocol('frontend: ' + JSON.stringify(messageObject));
         }
         if (test.onMessageSent) {
+            const domain = method.split('.')[0];
             const paramsObject = JSON.parse(JSON.stringify(params || {}));
-            test.onMessageSent({ domain, method, params: paramsObject, id: messageId, sessionId }, this.getTargetBySessionId(sessionId));
+            test.onMessageSent({ domain, method, params: paramsObject, id: messageId, sessionId });
         }
         ++this.#pendingResponsesCount;
         if (LongPollingMethods.has(method)) {
             this.#pendingLongPollingMessageIds.add(messageId);
         }
-        const session = this.#sessions.get(sessionId);
-        if (!session) {
-            return;
-        }
-        session.callbacks.set(messageId, { callback, method });
-        this.#connection.sendRawMessage(JSON.stringify(messageObject));
+        return new Promise(resolve => {
+            this.#callbacks.set(messageId, { resolve, method, sessionId });
+            this.#connection.sendRawMessage(JSON.stringify(messageObject));
+        });
     }
     sendRawMessageForTesting(method, params, callback, sessionId = '') {
-        const domain = method.split('.')[0];
-        this.sendMessage(sessionId, domain, method, params, callback || (() => { }));
+        void this.send(method, params, sessionId).then(response => {
+            if ('error' in response && response.error) {
+                callback?.(response.error, null);
+            }
+            else if ('result' in response) {
+                callback?.(null, response.result);
+            }
+        });
     }
     onMessage(message) {
         if (test.dumpProtocol) {
@@ -224,65 +206,35 @@ export class SessionRouter {
         }
         if (test.onMessageReceived) {
             const messageObjectCopy = JSON.parse((typeof message === 'string') ? message : JSON.stringify(message));
-            test.onMessageReceived(messageObjectCopy, this.getTargetBySessionId(messageObjectCopy.sessionId));
+            test.onMessageReceived(messageObjectCopy);
         }
         const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message);
-        // Send all messages to proxy connections.
-        let suppressUnknownMessageErrors = false;
-        for (const session of this.#sessions.values()) {
-            if (!session.proxyConnection) {
-                continue;
-            }
-            if (!session.proxyConnection.onMessage) {
-                InspectorBackend.reportProtocolError('Protocol Error: the session has a proxyConnection with no _onMessage', messageObject);
-                continue;
-            }
-            session.proxyConnection.onMessage(messageObject);
-            suppressUnknownMessageErrors = true;
-        }
         const sessionId = messageObject.sessionId || '';
         const session = this.#sessions.get(sessionId);
-        if (!session) {
-            if (!suppressUnknownMessageErrors) {
-                InspectorBackend.reportProtocolError('Protocol Error: the message with wrong session id', messageObject);
-            }
-            return;
-        }
-        // If this message is directly for the target controlled by the proxy connection, don't handle it.
-        if (session.proxyConnection) {
-            return;
-        }
-        if (session.target.getNeedsNodeJSPatching()) {
+        if (session?.target.getNeedsNodeJSPatching()) {
             NodeURL.patch(messageObject);
         }
-        if (messageObject.id !== undefined) { // just a response for some request
-            const callback = session.callbacks.get(messageObject.id);
-            session.callbacks.delete(messageObject.id);
+        if ('id' in messageObject && messageObject.id !== undefined) { // just a response for some request
+            const callback = this.#callbacks.get(messageObject.id);
+            this.#callbacks.delete(messageObject.id);
             if (!callback) {
-                if (messageObject.error?.code === ConnectionClosedErrorCode) {
-                    // Ignore the errors that are sent as responses after the session closes.
-                    return;
-                }
-                if (!suppressUnknownMessageErrors) {
-                    InspectorBackend.reportProtocolError('Protocol Error: the message with wrong id', messageObject);
-                }
+                // Ignore messages with unknown IDs, we might see puppeteer proxied messages here.
                 return;
             }
-            callback.callback(messageObject.error || null, messageObject.result || null);
+            callback.resolve(messageObject);
             --this.#pendingResponsesCount;
             this.#pendingLongPollingMessageIds.delete(messageObject.id);
             if (this.#pendingScripts.length && !this.hasOutstandingNonLongPollingRequests()) {
                 this.deprecatedRunAfterPendingDispatches();
             }
         }
-        else {
-            if (messageObject.method === undefined) {
-                InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
-                return;
-            }
+        else if ('method' in messageObject) {
             // This cast is justified as we just checked for the presence of messageObject.method.
-            const eventMessage = messageObject;
-            session.target.dispatch(eventMessage);
+            session?.target.dispatch(messageObject);
+            this.#observers.forEach(observer => observer.onEvent(messageObject));
+        }
+        else {
+            InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
         }
     }
     hasOutstandingNonLongPollingRequests() {
@@ -311,22 +263,6 @@ export class SessionRouter {
             }
         }
     }
-    static dispatchConnectionError(callback, method) {
-        const error = {
-            message: `Connection is closed, can\'t dispatch pending call to ${method}`,
-            code: ConnectionClosedErrorCode,
-            data: null,
-        };
-        window.setTimeout(() => callback(error, null), 0);
-    }
-    static dispatchUnregisterSessionError({ callback, method }) {
-        const error = {
-            message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
-            code: ConnectionClosedErrorCode,
-            data: null,
-        };
-        window.setTimeout(() => callback(error, null), 0);
-    }
 }
 export class TargetBase {
     needsNodeJSPatching;
@@ -337,18 +273,18 @@ export class TargetBase {
     constructor(needsNodeJSPatching, parentTarget, sessionId, connection) {
         this.needsNodeJSPatching = needsNodeJSPatching;
         this.sessionId = sessionId;
-        if ((!parentTarget && connection) || (!parentTarget && sessionId) || (connection && sessionId)) {
-            throw new Error('Either connection or sessionId (but not both) must be supplied for a child target');
+        if (parentTarget && !sessionId) {
+            throw new Error('Specifying a parent target requires a session ID');
         }
         let router;
-        if (sessionId && parentTarget && parentTarget.#router) {
+        if (parentTarget && parentTarget.#router) {
             router = parentTarget.#router;
         }
         else if (connection) {
             router = new SessionRouter(connection);
         }
         else {
-            router = new SessionRouter(connectionFactory());
+            router = new SessionRouter(ConnectionTransport.getFactory()());
         }
         this.#router = router;
         router.registerSession(this, this.sessionId);
@@ -638,6 +574,12 @@ export class TargetBase {
         return this.needsNodeJSPatching;
     }
 }
+/** These are not logged as console.error */
+const IGNORED_ERRORS = new Set([
+    CDPErrorStatus.DEVTOOLS_STUB_ERROR,
+    CDPErrorStatus.SERVER_ERROR,
+    CDPErrorStatus.SESSION_NOT_FOUND,
+]);
 /**
  * This is a class that serves as the prototype for a domains #agents (every target
  * has it's own set of #agents). The InspectorBackend keeps an instance of this class
@@ -648,113 +590,39 @@ export class TargetBase {
  * of the invoke_enable, etc. methods that the front-end uses.
  */
 class AgentPrototype {
-    replyArgs;
     description = '';
     metadata;
     domain;
     target;
     constructor(domain) {
-        this.replyArgs = {};
         this.domain = domain;
         this.metadata = {};
     }
     registerCommand(methodName, parameters, replyArgs, description) {
         const domainAndMethod = qualifyName(this.domain, methodName);
-        function sendMessagePromise(...args) {
-            return AgentPrototype.prototype.sendMessageToBackendPromise.call(this, domainAndMethod, parameters, args);
-        }
-        // @ts-expect-error Method code generation
-        this[methodName] = sendMessagePromise;
         this.metadata[domainAndMethod] = { parameters, description, replyArgs };
         function invoke(request = {}) {
             return this.invoke(domainAndMethod, request);
         }
         // @ts-expect-error Method code generation
         this['invoke_' + methodName] = invoke;
-        this.replyArgs[domainAndMethod] = replyArgs;
-    }
-    prepareParameters(method, parameters, args, errorCallback) {
-        const params = {};
-        let hasParams = false;
-        for (const param of parameters) {
-            const paramName = param.name;
-            const typeName = param.type;
-            const optionalFlag = param.optional;
-            if (!args.length && !optionalFlag) {
-                errorCallback(`Protocol Error: Invalid number of arguments for method '${method}' call. ` +
-                    `It must have the following arguments ${JSON.stringify(parameters)}'.`);
-                return null;
-            }
-            const value = args.shift();
-            if (optionalFlag && typeof value === 'undefined') {
-                continue;
-            }
-            const expectedJSType = typeName === 'array' ? 'object' : typeName;
-            if (typeof value !== expectedJSType) {
-                errorCallback(`Protocol Error: Invalid type of argument '${paramName}' for method '${method}' call. ` +
-                    `It must be '${typeName}' but it is '${typeof value}'.`);
-                return null;
-            }
-            params[paramName] = value;
-            hasParams = true;
-        }
-        if (args.length) {
-            errorCallback(`Protocol Error: Extra ${args.length} arguments in a call to method '${method}'.`);
-            return null;
-        }
-        return hasParams ? params : null;
-    }
-    sendMessageToBackendPromise(method, parameters, args) {
-        let errorMessage;
-        function onError(message) {
-            console.error(message);
-            errorMessage = message;
-        }
-        const params = this.prepareParameters(method, parameters, args, onError);
-        if (errorMessage) {
-            return Promise.resolve(null);
-        }
-        return new Promise(resolve => {
-            // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const callback = (error, result) => {
-                if (error) {
-                    if (!test.suppressRequestErrors && error.code !== DevToolsStubErrorCode && error.code !== GenericErrorCode &&
-                        error.code !== ConnectionClosedErrorCode) {
-                        console.error('Request ' + method + ' failed. ' + JSON.stringify(error));
-                    }
-                    resolve(null);
-                    return;
-                }
-                const args = this.replyArgs[method];
-                resolve(result && args.length ? result[args[0]] : undefined);
-            };
-            const router = this.target.router();
-            if (!router) {
-                SessionRouter.dispatchConnectionError(callback, method);
-            }
-            else {
-                router.sendMessage(this.target.sessionId, this.domain, method, params, callback);
-            }
-        });
     }
     invoke(method, request) {
-        return new Promise(fulfill => {
-            const callback = (error, result) => {
-                if (error && !test.suppressRequestErrors && error.code !== DevToolsStubErrorCode &&
-                    error.code !== GenericErrorCode && error.code !== ConnectionClosedErrorCode) {
-                    console.error('Request ' + method + ' failed. ' + JSON.stringify(error));
+        const router = this.target.router();
+        if (!router) {
+            return Promise.resolve({ result: null, getError: () => `Connection is closed, can\'t dispatch pending call to ${method}` });
+        }
+        return router.send(method, request, this.target.sessionId).then(response => {
+            if ('error' in response && response.error) {
+                if (!test.suppressRequestErrors && !IGNORED_ERRORS.has(response.error.code)) {
+                    console.error('Request ' + method + ' failed. ' + JSON.stringify(response.error));
                 }
-                const errorMessage = error?.message;
-                fulfill({ ...result, getError: () => errorMessage });
-            };
-            const router = this.target.router();
-            if (!router) {
-                SessionRouter.dispatchConnectionError(callback, method);
+                return { getError: () => response.error.message };
             }
-            else {
-                router.sendMessage(this.target.sessionId, this.domain, method, request, callback);
+            if ('result' in response) {
+                return { ...response.result, getError: () => undefined };
             }
+            return { getError: () => undefined };
         });
     }
 }

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/protocol_client.js

@@ -1,13 +1,8 @@
 // Copyright 2019 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
-import * as InspectorBackendCommands from '../../generated/InspectorBackendCommands.js';
+import * as CDPConnection from './CDPConnection.js';
+import * as ConnectionTransport from './ConnectionTransport.js';
 import * as InspectorBackend from './InspectorBackend.js';
 import * as NodeURL from './NodeURL.js';
-export { InspectorBackend, NodeURL, };
-// Create the global here because registering commands will involve putting
-// items onto the global.
-// @ts-expect-error Global namespace instantiation
-
-// FIXME: This instance of InspectorBackend should not be a side effect of importing this module.
-
+export { CDPConnection, ConnectionTransport, InspectorBackend, NodeURL, };

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/AnimationModel.js

@@ -678,12 +678,11 @@ export class AnimationGroup {
     #id;
     #scrollNode;
     #animations;
-    #paused;
+    #paused = false;
     constructor(animationModel, id, animations) {
         this.#animationModel = animationModel;
         this.#id = id;
         this.#animations = animations;
-        this.#paused = false;
     }
     isScrollDriven() {
         return Boolean(this.#animations[0]?.viewOrScrollTimeline());