chrome-devtools-mcp-for-extension 0.19.2 → 0.20.0

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 { 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;
+import * as InspectorBackendCommands from '../../generated/InspectorBackendCommands.js';
+import { CDPErrorStatus } from './CDPConnection.js';
+import { ConnectionTransport } from './ConnectionTransport.js';
+import { DevToolsCDPConnection } from './DevToolsCDPConnection.js';
 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 = {
@@ -128,227 +105,60 @@ export const test = {
      */
     onMessageReceived: null,
 };
-const LongPollingMethods = new Set(['CSS.takeComputedStyleUpdates']);
 export class SessionRouter {
     #connection;
-    #lastMessageId = 1;
-    #pendingResponsesCount = 0;
-    #pendingLongPollingMessageIds = new Set();
     #sessions = new Map();
-    #pendingScripts = [];
     constructor(connection) {
         this.#connection = connection;
-        test.deprecatedRunAfterPendingDispatches = this.deprecatedRunAfterPendingDispatches.bind(this);
-        test.sendRawMessage = this.sendRawMessageForTesting.bind(this);
-        this.#connection.setOnMessage(this.onMessage.bind(this));
-        this.#connection.setOnDisconnect(reason => {
-            const session = this.#sessions.get('');
-            if (session) {
-                session.target.dispose(reason);
-            }
-        });
+        this.#connection.observe(this);
     }
-    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 });
+    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);
+        if (this.#connection instanceof DevToolsCDPConnection) {
+            this.#connection.resolvePendingCalls(sessionId);
         }
         this.#sessions.delete(sessionId);
     }
-    getTargetBySessionId(sessionId) {
-        const session = this.#sessions.get(sessionId ? sessionId : '');
-        if (!session) {
-            return null;
+    onDisconnect(reason) {
+        const session = this.#sessions.get('');
+        if (session) {
+            session.target.dispose(reason);
         }
-        return session.target;
     }
-    nextMessageId() {
-        return this.#lastMessageId++;
-    }
-    connection() {
-        return this.#connection;
-    }
-    sendMessage(sessionId, domain, method, params, callback) {
-        const messageId = this.nextMessageId();
-        const messageObject = {
-            id: messageId,
-            method,
-        };
-        if (params) {
-            messageObject.params = params;
-        }
-        if (sessionId) {
-            messageObject.sessionId = sessionId;
-        }
-        if (test.dumpProtocol) {
-            test.dumpProtocol('frontend: ' + JSON.stringify(messageObject));
-        }
-        if (test.onMessageSent) {
-            const paramsObject = JSON.parse(JSON.stringify(params || {}));
-            test.onMessageSent({ domain, method, params: paramsObject, id: messageId, sessionId }, this.getTargetBySessionId(sessionId));
-        }
-        ++this.#pendingResponsesCount;
-        if (LongPollingMethods.has(method)) {
-            this.#pendingLongPollingMessageIds.add(messageId);
-        }
+    onEvent(event) {
+        const sessionId = event.sessionId || '';
         const session = this.#sessions.get(sessionId);
-        if (!session) {
-            return;
-        }
-        session.callbacks.set(messageId, { callback, method });
-        this.#connection.sendRawMessage(JSON.stringify(messageObject));
+        session?.target.dispatch(event);
     }
-    sendRawMessageForTesting(method, params, callback, sessionId = '') {
-        const domain = method.split('.')[0];
-        this.sendMessage(sessionId, domain, method, params, callback || (() => { }));
-    }
-    onMessage(message) {
-        if (test.dumpProtocol) {
-            test.dumpProtocol('backend: ' + ((typeof message === 'string') ? message : JSON.stringify(message)));
-        }
-        if (test.onMessageReceived) {
-            const messageObjectCopy = JSON.parse((typeof message === 'string') ? message : JSON.stringify(message));
-            test.onMessageReceived(messageObjectCopy, this.getTargetBySessionId(messageObjectCopy.sessionId));
-        }
-        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()) {
-            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 (!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);
-                }
-                return;
-            }
-            callback.callback(messageObject.error || null, messageObject.result || null);
-            --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;
-            }
-            // This cast is justified as we just checked for the presence of messageObject.method.
-            const eventMessage = messageObject;
-            session.target.dispatch(eventMessage);
-        }
-    }
-    hasOutstandingNonLongPollingRequests() {
-        return this.#pendingResponsesCount - this.#pendingLongPollingMessageIds.size > 0;
-    }
-    deprecatedRunAfterPendingDispatches(script) {
-        if (script) {
-            this.#pendingScripts.push(script);
-        }
-        // Execute all promises.
-        window.setTimeout(() => {
-            if (!this.hasOutstandingNonLongPollingRequests()) {
-                this.executeAfterPendingDispatches();
-            }
-            else {
-                this.deprecatedRunAfterPendingDispatches();
-            }
-        }, 0);
-    }
-    executeAfterPendingDispatches() {
-        if (!this.hasOutstandingNonLongPollingRequests()) {
-            const scripts = this.#pendingScripts;
-            this.#pendingScripts = [];
-            for (let id = 0; id < scripts.length; ++id) {
-                scripts[id]();
-            }
-        }
-    }
-    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);
+    get connection() {
+        return this.#connection;
     }
 }
 export class TargetBase {
-    needsNodeJSPatching;
     sessionId;
     #router;
     #agents = new Map();
     #dispatchers = new Map();
-    constructor(needsNodeJSPatching, parentTarget, sessionId, connection) {
-        this.needsNodeJSPatching = needsNodeJSPatching;
+    constructor(parentTarget, sessionId, connection) {
         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(new DevToolsCDPConnection(ConnectionTransport.getFactory()()));
         }
         this.#router = router;
         router.registerSession(this, this.sessionId);
@@ -380,9 +190,6 @@ export class TargetBase {
     isDisposed() {
         return !this.#router;
     }
-    markAsNodeJSForTest() {
-        this.needsNodeJSPatching = true;
-    }
     router() {
         return this.#router;
     }
@@ -634,10 +441,13 @@ export class TargetBase {
     registerWebAuthnDispatcher(dispatcher) {
         this.registerDispatcher('WebAuthn', dispatcher);
     }
-    getNeedsNodeJSPatching() {
-        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 +458,40 @@ 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 connection = this.target.router()?.connection;
+        if (!connection) {
+            return Promise.resolve({ result: null, getError: () => `Connection is closed, can\'t dispatch pending call to ${method}` });
+        }
+        return connection.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 DevToolsCDPConnection from './DevToolsCDPConnection.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, DevToolsCDPConnection, InspectorBackend, };

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

@@ -0,0 +1,54 @@
+// 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.
+/**
+ * Container for singletons scoped to a single DevTools universe.
+ *
+ * When wiring up dependencies, strongly prefer to pass all direct dependencies
+ * via constructor, and not just pass a {@link DevToolsContext} around. That would hide
+ * dependencies and we want to be explicit.
+ */
+export class DevToolsContext {
+    #instances = new Map();
+    get(ctor) {
+        const instance = this.#instances.get(ctor);
+        if (!instance) {
+            throw new Error(`No instance for ${ctor.name}. Ensure the bootstrapper creates it.`);
+        }
+        return instance;
+    }
+    /** @deprecated Should only be used by existing `instance` accessors. */
+    has(ctor) {
+        return this.#instances.has(ctor);
+    }
+    /**
+     * @deprecated Should only be used by existing `instance` accessors and the bootstrapper.
+     * Exists on the public interface only for migration purposes for now.
+     */
+    set(ctor, instance) {
+        // TODO(crbug.com/458180550): We need to throw here if an instance was already set!
+        this.#instances.set(ctor, instance);
+    }
+    /** @deprecated Should only be used by existing `removeInstance` static methods. */
+    delete(ctor) {
+        this.#instances.delete(ctor);
+    }
+}
+let gInstance = null;
+/**
+ * @deprecated Exists to migrate instance() methods.
+ */
+export function globalInstance() {
+    if (!gInstance) {
+        // TODO(crbug.com/458180550): This should really throw to prevent side-effects and globals
+        //                            from leaking all over the place.
+        gInstance = new DevToolsContext();
+    }
+    return gInstance;
+}
+/**
+ * @deprecated Should only be called by test setup and MainImpl
+ */
+export function setGlobalInstance(context) {
+    gInstance = context;
+}

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

@@ -1,5 +1,6 @@
 // Copyright 2020 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 DevToolsContext from './DevToolsContext.js';
 import * as Runtime from './Runtime.js';
-export { Runtime };
+export { DevToolsContext, Runtime, };

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

@@ -302,7 +302,7 @@ export class AnimationModel extends SDKModel {
         const animation = await AnimationImpl.parsePayload(this, payload);
         // Ignore Web Animations custom effects & groups.
         const keyframesRule = animation.source().keyframesRule();
-        if (animation.type() === 'WebAnimation' && keyframesRule && keyframesRule.keyframes().length === 0) {
+        if (animation.type() === 'WebAnimation' && keyframesRule?.keyframes().length === 0) {
             this.#pendingAnimations.delete(animation.id());
         }
         else {
@@ -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());

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

@@ -148,9 +148,6 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper {
         // Implemented as a requirement for being a SDKModelObserver.
     }
 }
-export function throttlingManager() {
-    return CPUThrottlingManager.instance();
-}
 export var CPUThrottlingRates;
 (function (CPUThrottlingRates) {
     CPUThrottlingRates[CPUThrottlingRates["NO_THROTTLING"] = 1] = "NO_THROTTLING";