@mcp-b/chrome-devtools-mcp 1.1.1 → 1.1.3

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

@@ -1,539 +0,0 @@
-// 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 { DevToolsCDPConnection } from './DevToolsCDPConnection.js';
-export const splitQualifiedName = (string) => {
-    const [domain, eventName] = string.split('.');
-    return [domain, eventName];
-};
-export const qualifyName = (domain, name) => {
-    return `${domain}.${name}`;
-};
-export class InspectorBackend {
-    agentPrototypes = new Map();
-    #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) {
-            map = new Map();
-            this.#eventParameterNamesForDomain.set(domain, map);
-        }
-        return map;
-    }
-    getOrCreateEventParameterNamesForDomainForTesting(domain) {
-        return this.getOrCreateEventParameterNamesForDomain(domain);
-    }
-    getEventParameterNames() {
-        return this.#eventParameterNamesForDomain;
-    }
-    static reportProtocolError(error, messageObject) {
-        console.error(error + ': ' + JSON.stringify(messageObject));
-    }
-    static reportProtocolWarning(error, messageObject) {
-        console.warn(error + ': ' + JSON.stringify(messageObject));
-    }
-    agentPrototype(domain) {
-        let prototype = this.agentPrototypes.get(domain);
-        if (!prototype) {
-            prototype = new AgentPrototype(domain);
-            this.agentPrototypes.set(domain, prototype);
-        }
-        return prototype;
-    }
-    registerCommand(method, parameters, replyArgs, description) {
-        const [domain, command] = splitQualifiedName(method);
-        this.agentPrototype(domain).registerCommand(command, parameters, replyArgs, description);
-    }
-    registerEnum(type, values) {
-        const [domain, name] = splitQualifiedName(type);
-        // @ts-expect-error globalThis global namespace pollution
-        if (!globalThis.Protocol[domain]) {
-            // @ts-expect-error globalThis global namespace pollution
-            globalThis.Protocol[domain] = {};
-        }
-        // @ts-expect-error globalThis global namespace pollution
-        globalThis.Protocol[domain][name] = values;
-        this.enumMap.set(type, values);
-    }
-    registerType(method, parameters) {
-        this.typeMap.set(method, parameters);
-    }
-    registerEvent(eventName, params) {
-        const domain = eventName.split('.')[0];
-        const eventParameterNames = this.getOrCreateEventParameterNamesForDomain(domain);
-        eventParameterNames.set(eventName, params);
-    }
-}
-export const test = {
-    /**
-     * This will get called for every protocol message.
-     * ProtocolClient.test.dumpProtocol = console.log
-     */
-    dumpProtocol: null,
-    /**
-     * Runs a function when no protocol activity is present.
-     * ProtocolClient.test.deprecatedRunAfterPendingDispatches(() => console.log('done'))
-     */
-    deprecatedRunAfterPendingDispatches: null,
-    /**
-     * Sends a raw message over main connection.
-     * ProtocolClient.test.sendRawMessage('Page.enable', {}, console.log)
-     */
-    sendRawMessage: null,
-    /**
-     * Set to true to not log any errors.
-     */
-    suppressRequestErrors: false,
-    /**
-     * Set to get notified about any messages sent over protocol.
-     */
-    onMessageSent: null,
-    /**
-     * Set to get notified about any messages received over protocol.
-     */
-    onMessageReceived: null,
-};
-export class SessionRouter {
-    #connection;
-    #sessions = new Map();
-    constructor(connection) {
-        this.#connection = connection;
-        this.#connection.observe(this);
-    }
-    registerSession(target, sessionId) {
-        this.#sessions.set(sessionId, { target });
-    }
-    unregisterSession(sessionId) {
-        const session = this.#sessions.get(sessionId);
-        if (!session) {
-            return;
-        }
-        if (this.#connection instanceof DevToolsCDPConnection) {
-            this.#connection.resolvePendingCalls(sessionId);
-        }
-        this.#sessions.delete(sessionId);
-    }
-    onDisconnect(reason) {
-        const session = this.#sessions.get('');
-        if (session) {
-            session.target.dispose(reason);
-        }
-    }
-    onEvent(event) {
-        const sessionId = event.sessionId || '';
-        const session = this.#sessions.get(sessionId);
-        session?.target.dispatch(event);
-    }
-    get connection() {
-        return this.#connection;
-    }
-}
-export class TargetBase {
-    sessionId;
-    #router;
-    #agents = new Map();
-    #dispatchers = new Map();
-    constructor(parentTarget, sessionId, connection) {
-        this.sessionId = sessionId;
-        if (parentTarget && !sessionId) {
-            throw new Error('Specifying a parent target requires a session ID');
-        }
-        let router;
-        if (parentTarget && parentTarget.#router) {
-            router = parentTarget.#router;
-        }
-        else if (connection) {
-            router = new SessionRouter(connection);
-        }
-        else {
-            router = new SessionRouter(new DevToolsCDPConnection(ConnectionTransport.getFactory()()));
-        }
-        this.#router = router;
-        router.registerSession(this, this.sessionId);
-        for (const [domain, agentPrototype] of inspectorBackend.agentPrototypes) {
-            const agent = Object.create((agentPrototype));
-            agent.target = this;
-            this.#agents.set(domain, agent);
-        }
-        for (const [domain, eventParameterNames] of inspectorBackend.getEventParameterNames().entries()) {
-            this.#dispatchers.set(domain, new DispatcherManager(eventParameterNames));
-        }
-    }
-    dispatch(eventMessage) {
-        const [domainName, method] = splitQualifiedName(eventMessage.method);
-        const dispatcher = this.#dispatchers.get(domainName);
-        if (!dispatcher) {
-            InspectorBackend.reportProtocolError(`Protocol Error: the message ${eventMessage.method} is for non-existing domain '${domainName}'`, eventMessage);
-            return;
-        }
-        dispatcher.dispatch(method, eventMessage);
-    }
-    dispose(_reason) {
-        if (!this.#router) {
-            return;
-        }
-        this.#router.unregisterSession(this.sessionId);
-        this.#router = null;
-    }
-    isDisposed() {
-        return !this.#router;
-    }
-    router() {
-        return this.#router;
-    }
-    // Agent accessors, keep alphabetically sorted.
-    /**
-     * Make sure that `Domain` is only ever instantiated with one protocol domain
-     * name, because if `Domain` allows multiple domains, the type is unsound.
-     */
-    getAgent(domain) {
-        const agent = this.#agents.get(domain);
-        if (!agent) {
-            throw new Error('Accessing undefined agent');
-        }
-        return agent;
-    }
-    accessibilityAgent() {
-        return this.getAgent('Accessibility');
-    }
-    animationAgent() {
-        return this.getAgent('Animation');
-    }
-    auditsAgent() {
-        return this.getAgent('Audits');
-    }
-    autofillAgent() {
-        return this.getAgent('Autofill');
-    }
-    browserAgent() {
-        return this.getAgent('Browser');
-    }
-    backgroundServiceAgent() {
-        return this.getAgent('BackgroundService');
-    }
-    cacheStorageAgent() {
-        return this.getAgent('CacheStorage');
-    }
-    cssAgent() {
-        return this.getAgent('CSS');
-    }
-    debuggerAgent() {
-        return this.getAgent('Debugger');
-    }
-    deviceOrientationAgent() {
-        return this.getAgent('DeviceOrientation');
-    }
-    domAgent() {
-        return this.getAgent('DOM');
-    }
-    domdebuggerAgent() {
-        return this.getAgent('DOMDebugger');
-    }
-    domsnapshotAgent() {
-        return this.getAgent('DOMSnapshot');
-    }
-    domstorageAgent() {
-        return this.getAgent('DOMStorage');
-    }
-    emulationAgent() {
-        return this.getAgent('Emulation');
-    }
-    eventBreakpointsAgent() {
-        return this.getAgent('EventBreakpoints');
-    }
-    extensionsAgent() {
-        return this.getAgent('Extensions');
-    }
-    fetchAgent() {
-        return this.getAgent('Fetch');
-    }
-    heapProfilerAgent() {
-        return this.getAgent('HeapProfiler');
-    }
-    indexedDBAgent() {
-        return this.getAgent('IndexedDB');
-    }
-    inputAgent() {
-        return this.getAgent('Input');
-    }
-    ioAgent() {
-        return this.getAgent('IO');
-    }
-    inspectorAgent() {
-        return this.getAgent('Inspector');
-    }
-    layerTreeAgent() {
-        return this.getAgent('LayerTree');
-    }
-    logAgent() {
-        return this.getAgent('Log');
-    }
-    mediaAgent() {
-        return this.getAgent('Media');
-    }
-    memoryAgent() {
-        return this.getAgent('Memory');
-    }
-    networkAgent() {
-        return this.getAgent('Network');
-    }
-    overlayAgent() {
-        return this.getAgent('Overlay');
-    }
-    pageAgent() {
-        return this.getAgent('Page');
-    }
-    preloadAgent() {
-        return this.getAgent('Preload');
-    }
-    profilerAgent() {
-        return this.getAgent('Profiler');
-    }
-    performanceAgent() {
-        return this.getAgent('Performance');
-    }
-    runtimeAgent() {
-        return this.getAgent('Runtime');
-    }
-    securityAgent() {
-        return this.getAgent('Security');
-    }
-    serviceWorkerAgent() {
-        return this.getAgent('ServiceWorker');
-    }
-    storageAgent() {
-        return this.getAgent('Storage');
-    }
-    systemInfo() {
-        return this.getAgent('SystemInfo');
-    }
-    targetAgent() {
-        return this.getAgent('Target');
-    }
-    tracingAgent() {
-        return this.getAgent('Tracing');
-    }
-    webAudioAgent() {
-        return this.getAgent('WebAudio');
-    }
-    webAuthnAgent() {
-        return this.getAgent('WebAuthn');
-    }
-    // Dispatcher registration and de-registration, keep alphabetically sorted.
-    /**
-     * Make sure that `Domain` is only ever instantiated with one protocol domain
-     * name, because if `Domain` allows multiple domains, the type is unsound.
-     */
-    registerDispatcher(domain, dispatcher) {
-        const manager = this.#dispatchers.get(domain);
-        if (!manager) {
-            return;
-        }
-        manager.addDomainDispatcher(dispatcher);
-    }
-    /**
-     * Make sure that `Domain` is only ever instantiated with one protocol domain
-     * name, because if `Domain` allows multiple domains, the type is unsound.
-     */
-    unregisterDispatcher(domain, dispatcher) {
-        const manager = this.#dispatchers.get(domain);
-        if (!manager) {
-            return;
-        }
-        manager.removeDomainDispatcher(dispatcher);
-    }
-    registerAccessibilityDispatcher(dispatcher) {
-        this.registerDispatcher('Accessibility', dispatcher);
-    }
-    registerAutofillDispatcher(dispatcher) {
-        this.registerDispatcher('Autofill', dispatcher);
-    }
-    registerAnimationDispatcher(dispatcher) {
-        this.registerDispatcher('Animation', dispatcher);
-    }
-    registerAuditsDispatcher(dispatcher) {
-        this.registerDispatcher('Audits', dispatcher);
-    }
-    registerCSSDispatcher(dispatcher) {
-        this.registerDispatcher('CSS', dispatcher);
-    }
-    registerBackgroundServiceDispatcher(dispatcher) {
-        this.registerDispatcher('BackgroundService', dispatcher);
-    }
-    registerDebuggerDispatcher(dispatcher) {
-        this.registerDispatcher('Debugger', dispatcher);
-    }
-    unregisterDebuggerDispatcher(dispatcher) {
-        this.unregisterDispatcher('Debugger', dispatcher);
-    }
-    registerDOMDispatcher(dispatcher) {
-        this.registerDispatcher('DOM', dispatcher);
-    }
-    registerDOMStorageDispatcher(dispatcher) {
-        this.registerDispatcher('DOMStorage', dispatcher);
-    }
-    registerFetchDispatcher(dispatcher) {
-        this.registerDispatcher('Fetch', dispatcher);
-    }
-    registerHeapProfilerDispatcher(dispatcher) {
-        this.registerDispatcher('HeapProfiler', dispatcher);
-    }
-    registerInspectorDispatcher(dispatcher) {
-        this.registerDispatcher('Inspector', dispatcher);
-    }
-    registerLayerTreeDispatcher(dispatcher) {
-        this.registerDispatcher('LayerTree', dispatcher);
-    }
-    registerLogDispatcher(dispatcher) {
-        this.registerDispatcher('Log', dispatcher);
-    }
-    registerMediaDispatcher(dispatcher) {
-        this.registerDispatcher('Media', dispatcher);
-    }
-    registerNetworkDispatcher(dispatcher) {
-        this.registerDispatcher('Network', dispatcher);
-    }
-    registerOverlayDispatcher(dispatcher) {
-        this.registerDispatcher('Overlay', dispatcher);
-    }
-    registerPageDispatcher(dispatcher) {
-        this.registerDispatcher('Page', dispatcher);
-    }
-    registerPreloadDispatcher(dispatcher) {
-        this.registerDispatcher('Preload', dispatcher);
-    }
-    registerProfilerDispatcher(dispatcher) {
-        this.registerDispatcher('Profiler', dispatcher);
-    }
-    registerRuntimeDispatcher(dispatcher) {
-        this.registerDispatcher('Runtime', dispatcher);
-    }
-    registerSecurityDispatcher(dispatcher) {
-        this.registerDispatcher('Security', dispatcher);
-    }
-    registerServiceWorkerDispatcher(dispatcher) {
-        this.registerDispatcher('ServiceWorker', dispatcher);
-    }
-    registerStorageDispatcher(dispatcher) {
-        this.registerDispatcher('Storage', dispatcher);
-    }
-    registerTargetDispatcher(dispatcher) {
-        this.registerDispatcher('Target', dispatcher);
-    }
-    registerTracingDispatcher(dispatcher) {
-        this.registerDispatcher('Tracing', dispatcher);
-    }
-    registerWebAudioDispatcher(dispatcher) {
-        this.registerDispatcher('WebAudio', dispatcher);
-    }
-    registerWebAuthnDispatcher(dispatcher) {
-        this.registerDispatcher('WebAuthn', dispatcher);
-    }
-}
-/** 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
- * per domain, and each TargetBase creates its #agents (via Object.create) and installs
- * this instance as prototype.
- *
- * The reasons this is done is so that on the prototypes we can install the implementations
- * of the invoke_enable, etc. methods that the front-end uses.
- */
-class AgentPrototype {
-    description = '';
-    metadata;
-    domain;
-    target;
-    constructor(domain) {
-        this.domain = domain;
-        this.metadata = {};
-    }
-    registerCommand(methodName, parameters, replyArgs, description) {
-        const domainAndMethod = qualifyName(this.domain, methodName);
-        this.metadata[domainAndMethod] = { parameters, description, replyArgs };
-        function invoke(request = {}) {
-            return this.invoke(domainAndMethod, request);
-        }
-        // @ts-expect-error Method code generation
-        this['invoke_' + methodName] = invoke;
-    }
-    invoke(method, request) {
-        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));
-                }
-                return { getError: () => response.error.message };
-            }
-            if ('result' in response) {
-                return { ...response.result, getError: () => undefined };
-            }
-            return { getError: () => undefined };
-        });
-    }
-}
-/**
- * A `DispatcherManager` has a collection of #dispatchers that implement one of the
- * `ProtocolProxyApi.{Foo}Dispatcher` interfaces. Each target uses one of these per
- * domain to manage the registered #dispatchers. The class knows the parameter names
- * of the events via `#eventArgs`, which is a map managed by the inspector back-end
- * so that there is only one map per domain that is shared among all DispatcherManagers.
- */
-class DispatcherManager {
-    #eventArgs;
-    #dispatchers = [];
-    constructor(eventArgs) {
-        this.#eventArgs = eventArgs;
-    }
-    addDomainDispatcher(dispatcher) {
-        this.#dispatchers.push(dispatcher);
-    }
-    removeDomainDispatcher(dispatcher) {
-        const index = this.#dispatchers.indexOf(dispatcher);
-        if (index === -1) {
-            return;
-        }
-        this.#dispatchers.splice(index, 1);
-    }
-    dispatch(event, messageObject) {
-        if (!this.#dispatchers.length) {
-            return;
-        }
-        if (!this.#eventArgs.has(messageObject.method)) {
-            InspectorBackend.reportProtocolWarning(`Protocol Warning: Attempted to dispatch an unspecified event '${messageObject.method}'`, messageObject);
-            return;
-        }
-        for (let index = 0; index < this.#dispatchers.length; ++index) {
-            const dispatcher = this.#dispatchers[index];
-            if (event in dispatcher) {
-                const f = dispatcher[event];
-                // @ts-expect-error Can't type check the dispatch.
-                f.call(dispatcher, messageObject.params);
-            }
-        }
-    }
-}
-export const inspectorBackend = new InspectorBackend();

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

@@ -1,8 +0,0 @@
-// 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 CDPConnection from './CDPConnection.js';
-import * as ConnectionTransport from './ConnectionTransport.js';
-import * as DevToolsCDPConnection from './DevToolsCDPConnection.js';
-import * as InspectorBackend from './InspectorBackend.js';
-export { CDPConnection, ConnectionTransport, DevToolsCDPConnection, InspectorBackend, };

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

@@ -1,54 +0,0 @@
-// 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/Runtime.js

@@ -1,11 +0,0 @@
-
-export function getChromeVersion() { return ''; };
-export const hostConfig = {};
-export const Runtime = {
-  isDescriptorEnabled: () => true,
-  queryParam: () => null,
-}
-export const experiments = {
-  isEnabled: () => false,
-}
-  

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

@@ -1,6 +0,0 @@
-// 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 { DevToolsContext, Runtime, };