chrome-devtools-mcp 0.0.1 → 0.0.2

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

@@ -0,0 +1,232 @@
+// Copyright 2018 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 i18n from '../../core/i18n/i18n.js';
+import * as Common from '../common/common.js';
+import * as Host from '../host/host.js';
+import { ParallelConnection } from './Connections.js';
+import { ResourceTreeModel } from './ResourceTreeModel.js';
+import { SDKModel } from './SDKModel.js';
+import { Type } from './Target.js';
+import { TargetManager } from './TargetManager.js';
+const UIStrings = {
+    /**
+     * @description Text that refers to the main target. The main target is the primary webpage that
+     * DevTools is connected to. This text is used in various places in the UI as a label/name to inform
+     * the user which target/webpage they are currently connected to, as DevTools may connect to multiple
+     * targets at the same time in some scenarios.
+     */
+    main: 'Main',
+};
+const str_ = i18n.i18n.registerUIStrings('core/sdk/ChildTargetManager.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class ChildTargetManager extends SDKModel {
+    #targetManager;
+    #parentTarget;
+    #targetAgent;
+    #targetInfos = new Map();
+    #childTargetsBySessionId = new Map();
+    #childTargetsById = new Map();
+    #parallelConnections = new Map();
+    #parentTargetId = null;
+    constructor(parentTarget) {
+        super(parentTarget);
+        this.#targetManager = parentTarget.targetManager();
+        this.#parentTarget = parentTarget;
+        this.#targetAgent = parentTarget.targetAgent();
+        parentTarget.registerTargetDispatcher(this);
+        const browserTarget = this.#targetManager.browserTarget();
+        if (browserTarget) {
+            if (browserTarget !== parentTarget) {
+                void browserTarget.targetAgent().invoke_autoAttachRelated({ targetId: parentTarget.id(), waitForDebuggerOnStart: true });
+            }
+        }
+        else if (parentTarget.type() === Type.NODE) {
+            void this.#targetAgent.invoke_setAutoAttach({ autoAttach: true, waitForDebuggerOnStart: true, flatten: false });
+        }
+        else {
+            void this.#targetAgent.invoke_setAutoAttach({ autoAttach: true, waitForDebuggerOnStart: true, flatten: true });
+        }
+        if (parentTarget.parentTarget()?.type() !== Type.FRAME && !Host.InspectorFrontendHost.isUnderTest()) {
+            void this.#targetAgent.invoke_setDiscoverTargets({ discover: true });
+            void this.#targetAgent.invoke_setRemoteLocations({ locations: [{ host: 'localhost', port: 9229 }] });
+        }
+    }
+    static install(attachCallback) {
+        ChildTargetManager.attachCallback = attachCallback;
+        SDKModel.register(ChildTargetManager, { capabilities: 32 /* Capability.TARGET */, autostart: true });
+    }
+    childTargets() {
+        return Array.from(this.#childTargetsBySessionId.values());
+    }
+    async suspendModel() {
+        await this.#targetAgent.invoke_setAutoAttach({ autoAttach: true, waitForDebuggerOnStart: false, flatten: true });
+    }
+    async resumeModel() {
+        await this.#targetAgent.invoke_setAutoAttach({ autoAttach: true, waitForDebuggerOnStart: true, flatten: true });
+    }
+    dispose() {
+        for (const sessionId of this.#childTargetsBySessionId.keys()) {
+            this.detachedFromTarget({ sessionId, targetId: undefined });
+        }
+    }
+    targetCreated({ targetInfo }) {
+        this.#targetInfos.set(targetInfo.targetId, targetInfo);
+        this.fireAvailableTargetsChanged();
+        this.dispatchEventToListeners("TargetCreated" /* Events.TARGET_CREATED */, targetInfo);
+    }
+    targetInfoChanged({ targetInfo }) {
+        this.#targetInfos.set(targetInfo.targetId, targetInfo);
+        const target = this.#childTargetsById.get(targetInfo.targetId);
+        if (target) {
+            void target.setHasCrashed(false);
+            if (target.targetInfo()?.subtype === 'prerender' && !targetInfo.subtype) {
+                const resourceTreeModel = target.model(ResourceTreeModel);
+                target.updateTargetInfo(targetInfo);
+                if (resourceTreeModel?.mainFrame) {
+                    resourceTreeModel.primaryPageChanged(resourceTreeModel.mainFrame, "Activation" /* PrimaryPageChangeType.ACTIVATION */);
+                }
+                target.setName(i18nString(UIStrings.main));
+            }
+            else {
+                target.updateTargetInfo(targetInfo);
+            }
+        }
+        this.fireAvailableTargetsChanged();
+        this.dispatchEventToListeners("TargetInfoChanged" /* Events.TARGET_INFO_CHANGED */, targetInfo);
+    }
+    targetDestroyed({ targetId }) {
+        this.#targetInfos.delete(targetId);
+        this.fireAvailableTargetsChanged();
+        this.dispatchEventToListeners("TargetDestroyed" /* Events.TARGET_DESTROYED */, targetId);
+    }
+    targetCrashed({ targetId }) {
+        const target = this.#childTargetsById.get(targetId);
+        if (target) {
+            target.setHasCrashed(true);
+        }
+    }
+    fireAvailableTargetsChanged() {
+        TargetManager.instance().dispatchEventToListeners("AvailableTargetsChanged" /* TargetManagerEvents.AVAILABLE_TARGETS_CHANGED */, [...this.#targetInfos.values()]);
+    }
+    async getParentTargetId() {
+        if (!this.#parentTargetId) {
+            this.#parentTargetId = (await this.#parentTarget.targetAgent().invoke_getTargetInfo({})).targetInfo.targetId;
+        }
+        return this.#parentTargetId;
+    }
+    async getTargetInfo() {
+        return (await this.#parentTarget.targetAgent().invoke_getTargetInfo({})).targetInfo;
+    }
+    async attachedToTarget({ sessionId, targetInfo, waitingForDebugger }) {
+        if (this.#parentTargetId === targetInfo.targetId) {
+            return;
+        }
+        let type = Type.BROWSER;
+        let targetName = '';
+        if (targetInfo.type === 'worker' && targetInfo.title && targetInfo.title !== targetInfo.url) {
+            targetName = targetInfo.title;
+        }
+        else if (!['page', 'iframe', 'webview'].includes(targetInfo.type)) {
+            const KNOWN_FRAME_PATTERNS = [
+                '^chrome://print/$',
+                '^chrome://file-manager/',
+                '^chrome://feedback/',
+                '^chrome://.*\\.top-chrome/$',
+                '^chrome://view-cert/$',
+                '^devtools://',
+            ];
+            if (KNOWN_FRAME_PATTERNS.some(p => targetInfo.url.match(p))) {
+                type = Type.FRAME;
+            }
+            else {
+                const parsedURL = Common.ParsedURL.ParsedURL.fromString(targetInfo.url);
+                targetName =
+                    parsedURL ? parsedURL.lastPathComponentWithFragment() : '#' + (++ChildTargetManager.lastAnonymousTargetId);
+            }
+        }
+        if (targetInfo.type === 'iframe' || targetInfo.type === 'webview') {
+            type = Type.FRAME;
+        }
+        else if (targetInfo.type === 'background_page' || targetInfo.type === 'app' || targetInfo.type === 'popup_page') {
+            type = Type.FRAME;
+        }
+        else if (targetInfo.type === 'page') {
+            type = Type.FRAME;
+        }
+        else if (targetInfo.type === 'worker') {
+            type = Type.Worker;
+        }
+        else if (targetInfo.type === 'worklet') {
+            type = Type.WORKLET;
+        }
+        else if (targetInfo.type === 'shared_worker') {
+            type = Type.SHARED_WORKER;
+        }
+        else if (targetInfo.type === 'shared_storage_worklet') {
+            type = Type.SHARED_STORAGE_WORKLET;
+        }
+        else if (targetInfo.type === 'service_worker') {
+            type = Type.ServiceWorker;
+        }
+        else if (targetInfo.type === 'auction_worklet') {
+            type = Type.AUCTION_WORKLET;
+        }
+        else if (targetInfo.type === 'node_worker') {
+            type = Type.NODE_WORKER;
+        }
+        const target = this.#targetManager.createTarget(targetInfo.targetId, targetName, type, this.#parentTarget, sessionId, undefined, undefined, targetInfo);
+        this.#childTargetsBySessionId.set(sessionId, target);
+        this.#childTargetsById.set(target.id(), target);
+        if (ChildTargetManager.attachCallback) {
+            await ChildTargetManager.attachCallback({ target, waitingForDebugger });
+        }
+        // [crbug/1423096] Invoking this on a worker session that is not waiting for the debugger can force the worker
+        // to resume even if there is another session waiting for the debugger.
+        if (waitingForDebugger) {
+            void target.runtimeAgent().invoke_runIfWaitingForDebugger();
+        }
+    }
+    detachedFromTarget({ sessionId }) {
+        if (this.#parallelConnections.has(sessionId)) {
+            this.#parallelConnections.delete(sessionId);
+        }
+        else {
+            const target = this.#childTargetsBySessionId.get(sessionId);
+            if (target) {
+                target.dispose('target terminated');
+                this.#childTargetsBySessionId.delete(sessionId);
+                this.#childTargetsById.delete(target.id());
+            }
+        }
+    }
+    receivedMessageFromTarget({}) {
+        // We use flatten protocol.
+    }
+    async createParallelConnection(onMessage) {
+        // The main Target id is actually just `main`, instead of the real targetId.
+        // Get the real id (requires an async operation) so that it can be used synchronously later.
+        const targetId = await this.getParentTargetId();
+        const { connection, sessionId } = await this.createParallelConnectionAndSessionForTarget(this.#parentTarget, targetId);
+        connection.setOnMessage(onMessage);
+        this.#parallelConnections.set(sessionId, connection);
+        return { connection, sessionId };
+    }
+    async createParallelConnectionAndSessionForTarget(target, targetId) {
+        const targetAgent = target.targetAgent();
+        const targetRouter = target.router();
+        const sessionId = (await targetAgent.invoke_attachToTarget({ targetId, flatten: true })).sessionId;
+        const connection = new ParallelConnection(targetRouter.connection(), sessionId);
+        targetRouter.registerSession(target, sessionId, connection);
+        connection.setOnDisconnect(() => {
+            targetRouter.unregisterSession(sessionId);
+            void targetAgent.invoke_detachFromTarget({ sessionId });
+        });
+        return { connection, sessionId };
+    }
+    targetInfos() {
+        return Array.from(this.#targetInfos.values());
+    }
+    static lastAnonymousTargetId = 0;
+    static attachCallback;
+}

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

@@ -0,0 +1,47 @@
+// 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 TextUtils from '../../models/text_utils/text_utils.js';
+import * as i18n from '../i18n/i18n.js';
+import { PageResourceLoader } from './PageResourceLoader.js';
+const UIStrings = {
+    /**
+     * @description Error message when failing to fetch a resource referenced in a source map
+     * @example {https://example.com/sourcemap.map} PH1
+     * @example {An error occurred} PH2
+     */
+    couldNotLoadContentForSS: 'Could not load content for {PH1} ({PH2})',
+};
+const str_ = i18n.i18n.registerUIStrings('core/sdk/CompilerSourceMappingContentProvider.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class CompilerSourceMappingContentProvider {
+    #sourceURL;
+    #contentType;
+    #initiator;
+    constructor(sourceURL, contentType, initiator) {
+        this.#sourceURL = sourceURL;
+        this.#contentType = contentType;
+        this.#initiator = initiator;
+    }
+    contentURL() {
+        return this.#sourceURL;
+    }
+    contentType() {
+        return this.#contentType;
+    }
+    async requestContentData() {
+        try {
+            const { content } = await PageResourceLoader.instance().loadResource(this.#sourceURL, this.#initiator);
+            return new TextUtils.ContentData.ContentData(content, /* isBase64=*/ false, this.#contentType.canonicalMimeType());
+        }
+        catch (e) {
+            const error = i18nString(UIStrings.couldNotLoadContentForSS, { PH1: this.#sourceURL, PH2: e.message });
+            console.error(error);
+            return { error };
+        }
+    }
+    async searchInContent(query, caseSensitive, isRegex) {
+        const contentData = await this.requestContentData();
+        return TextUtils.TextUtils.performSearchInContentData(contentData, query, caseSensitive, isRegex);
+    }
+}

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

@@ -0,0 +1,242 @@
+// Copyright 2015 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 i18n from '../../core/i18n/i18n.js';
+import * as Common from '../common/common.js';
+import * as Host from '../host/host.js';
+import * as ProtocolClient from '../protocol_client/protocol_client.js';
+import * as Root from '../root/root.js';
+import { RehydratingConnection } from './RehydratingConnection.js';
+const UIStrings = {
+    /**
+     * @description Text on the remote debugging window to indicate the connection is lost
+     */
+    websocketDisconnected: 'WebSocket disconnected',
+};
+const str_ = i18n.i18n.registerUIStrings('core/sdk/Connections.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class MainConnection {
+    onMessage = null;
+    #onDisconnect = null;
+    #messageBuffer = '';
+    #messageSize = 0;
+    #eventListeners;
+    constructor() {
+        this.#eventListeners = [
+            Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.addEventListener(Host.InspectorFrontendHostAPI.Events.DispatchMessage, this.dispatchMessage, this),
+            Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.addEventListener(Host.InspectorFrontendHostAPI.Events.DispatchMessageChunk, this.dispatchMessageChunk, this),
+        ];
+    }
+    setOnMessage(onMessage) {
+        this.onMessage = onMessage;
+    }
+    setOnDisconnect(onDisconnect) {
+        this.#onDisconnect = onDisconnect;
+    }
+    sendRawMessage(message) {
+        if (this.onMessage) {
+            Host.InspectorFrontendHost.InspectorFrontendHostInstance.sendMessageToBackend(message);
+        }
+    }
+    dispatchMessage(event) {
+        if (this.onMessage) {
+            this.onMessage.call(null, event.data);
+        }
+    }
+    dispatchMessageChunk(event) {
+        const { messageChunk, messageSize } = event.data;
+        if (messageSize) {
+            this.#messageBuffer = '';
+            this.#messageSize = messageSize;
+        }
+        this.#messageBuffer += messageChunk;
+        if (this.#messageBuffer.length === this.#messageSize && this.onMessage) {
+            this.onMessage.call(null, this.#messageBuffer);
+            this.#messageBuffer = '';
+            this.#messageSize = 0;
+        }
+    }
+    async disconnect() {
+        const onDisconnect = this.#onDisconnect;
+        Common.EventTarget.removeEventListeners(this.#eventListeners);
+        this.#onDisconnect = null;
+        this.onMessage = null;
+        if (onDisconnect) {
+            onDisconnect.call(null, 'force disconnect');
+        }
+    }
+}
+export class WebSocketConnection {
+    #socket;
+    onMessage = null;
+    #onDisconnect = null;
+    #onWebSocketDisconnect;
+    #connected = false;
+    #messages = [];
+    constructor(url, onWebSocketDisconnect) {
+        this.#socket = new WebSocket(url);
+        this.#socket.onerror = this.onError.bind(this);
+        this.#socket.onopen = this.onOpen.bind(this);
+        this.#socket.onmessage = (messageEvent) => {
+            if (this.onMessage) {
+                this.onMessage.call(null, messageEvent.data);
+            }
+        };
+        this.#socket.onclose = this.onClose.bind(this);
+        this.#onWebSocketDisconnect = onWebSocketDisconnect;
+    }
+    setOnMessage(onMessage) {
+        this.onMessage = onMessage;
+    }
+    setOnDisconnect(onDisconnect) {
+        this.#onDisconnect = onDisconnect;
+    }
+    onError() {
+        if (this.#onWebSocketDisconnect) {
+            this.#onWebSocketDisconnect.call(null, i18nString(UIStrings.websocketDisconnected));
+        }
+        if (this.#onDisconnect) {
+            // This is called if error occurred while connecting.
+            this.#onDisconnect.call(null, 'connection failed');
+        }
+        this.close();
+    }
+    onOpen() {
+        this.#connected = true;
+        if (this.#socket) {
+            this.#socket.onerror = console.error;
+            for (const message of this.#messages) {
+                this.#socket.send(message);
+            }
+        }
+        this.#messages = [];
+    }
+    onClose() {
+        if (this.#onWebSocketDisconnect) {
+            this.#onWebSocketDisconnect.call(null, i18nString(UIStrings.websocketDisconnected));
+        }
+        if (this.#onDisconnect) {
+            this.#onDisconnect.call(null, 'websocket closed');
+        }
+        this.close();
+    }
+    close(callback) {
+        if (this.#socket) {
+            this.#socket.onerror = null;
+            this.#socket.onopen = null;
+            this.#socket.onclose = callback || null;
+            this.#socket.onmessage = null;
+            this.#socket.close();
+            this.#socket = null;
+        }
+        this.#onWebSocketDisconnect = null;
+    }
+    sendRawMessage(message) {
+        if (this.#connected && this.#socket) {
+            this.#socket.send(message);
+        }
+        else {
+            this.#messages.push(message);
+        }
+    }
+    disconnect() {
+        return new Promise(fulfill => {
+            this.close(() => {
+                if (this.#onDisconnect) {
+                    this.#onDisconnect.call(null, 'force disconnect');
+                }
+                fulfill();
+            });
+        });
+    }
+}
+export class StubConnection {
+    onMessage = null;
+    #onDisconnect = null;
+    setOnMessage(onMessage) {
+        this.onMessage = onMessage;
+    }
+    setOnDisconnect(onDisconnect) {
+        this.#onDisconnect = onDisconnect;
+    }
+    sendRawMessage(message) {
+        window.setTimeout(this.respondWithError.bind(this, message), 0);
+    }
+    respondWithError(message) {
+        const messageObject = JSON.parse(message);
+        const error = {
+            message: 'This is a stub connection, can\'t dispatch message.',
+            code: ProtocolClient.InspectorBackend.DevToolsStubErrorCode,
+            data: messageObject,
+        };
+        if (this.onMessage) {
+            this.onMessage.call(null, { id: messageObject.id, error });
+        }
+    }
+    async disconnect() {
+        if (this.#onDisconnect) {
+            this.#onDisconnect.call(null, 'force disconnect');
+        }
+        this.#onDisconnect = null;
+        this.onMessage = null;
+    }
+}
+export class ParallelConnection {
+    #connection;
+    #sessionId;
+    onMessage = null;
+    #onDisconnect = null;
+    constructor(connection, sessionId) {
+        this.#connection = connection;
+        this.#sessionId = sessionId;
+    }
+    setOnMessage(onMessage) {
+        this.onMessage = onMessage;
+    }
+    setOnDisconnect(onDisconnect) {
+        this.#onDisconnect = onDisconnect;
+    }
+    getOnDisconnect() {
+        return this.#onDisconnect;
+    }
+    sendRawMessage(message) {
+        const messageObject = JSON.parse(message);
+        // If the message isn't for a specific session, it must be for the root session.
+        if (!messageObject.sessionId) {
+            messageObject.sessionId = this.#sessionId;
+        }
+        this.#connection.sendRawMessage(JSON.stringify(messageObject));
+    }
+    getSessionId() {
+        return this.#sessionId;
+    }
+    async disconnect() {
+        if (this.#onDisconnect) {
+            this.#onDisconnect.call(null, 'force disconnect');
+        }
+        this.#onDisconnect = null;
+        this.onMessage = null;
+    }
+}
+export async function initMainConnection(createRootTarget, onConnectionLost) {
+    ProtocolClient.InspectorBackend.Connection.setFactory(createMainConnection.bind(null, onConnectionLost));
+    await createRootTarget();
+    Host.InspectorFrontendHost.InspectorFrontendHostInstance.connectionReady();
+}
+function createMainConnection(onConnectionLost) {
+    if (Root.Runtime.getPathName().includes('rehydrated_devtools_app')) {
+        return new RehydratingConnection(onConnectionLost);
+    }
+    const wsParam = Root.Runtime.Runtime.queryParam('ws');
+    const wssParam = Root.Runtime.Runtime.queryParam('wss');
+    if (wsParam || wssParam) {
+        const ws = (wsParam ? `ws://${wsParam}` : `wss://${wssParam}`);
+        return new WebSocketConnection(ws, onConnectionLost);
+    }
+    const notEmbeddedOrWs = Host.InspectorFrontendHost.InspectorFrontendHostInstance.isHostedMode();
+    if (notEmbeddedOrWs) {
+        // eg., hosted mode (e.g. `http://localhost:9222/devtools/inspector.html`) without a WebSocket URL,
+        return new StubConnection();
+    }
+    return new MainConnection();
+}