@mcp-b/chrome-devtools-mcp 2.0.13 → 2.2.0

package/build/vendor/chrome-devtools-frontend/front_end/core/sdk/EnhancedTracesParser.js

@@ -1,364 +0,0 @@
-// Copyright 2024 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 Common from '../common/common.js';
-import { UserVisibleError } from '../platform/platform.js';
-export class EnhancedTracesParser {
-    #trace;
-    #scriptRundownEvents = [];
-    #scriptToV8Context = new Map();
-    #scriptToFrame = new Map();
-    #scriptToScriptSource = new Map();
-    #largeScriptToScriptSource = new Map();
-    #scriptToSourceLength = new Map();
-    #targets = [];
-    #executionContexts = [];
-    #scripts = [];
-    #resources = [];
-    static enhancedTraceVersion = 1;
-    constructor(trace) {
-        this.#trace = trace;
-        // Initialize with the trace provided.
-        try {
-            this.parseEnhancedTrace();
-        }
-        catch (e) {
-            throw new UserVisibleError.UserVisibleError(e);
-        }
-    }
-    parseEnhancedTrace() {
-        for (const event of this.#trace.traceEvents) {
-            if (this.isTracingStartedInBrowser(event)) {
-                // constructs all targets by devtools.timeline TracingStartedInBrowser
-                const data = event.args?.data;
-                for (const frame of data.frames) {
-                    if (frame.url === 'about:blank') {
-                        continue;
-                    }
-                    if (!frame.isInPrimaryMainFrame) {
-                        continue;
-                    }
-                    const frameId = frame.frame;
-                    if (!this.#targets.find(target => target.targetId === frameId)) {
-                        const frameType = frame.isOutermostMainFrame ? 'page' : 'iframe';
-                        this.#targets.push({
-                            targetId: frameId,
-                            type: frameType,
-                            pid: frame.processId,
-                            url: frame.url,
-                        });
-                    }
-                }
-            }
-            else if (this.isFunctionCallEvent(event)) {
-                // constructs all script to frame mapping with devtools.timeline FunctionCall
-                const data = event.args?.data;
-                if (data.isolate) {
-                    this.#scriptToFrame.set(this.getScriptIsolateId(data.isolate, data.scriptId), data.frame);
-                }
-            }
-            else if (this.isRundownScriptCompiled(event)) {
-                // Set up script to v8 context mapping
-                const data = event.args?.data;
-                this.#scriptToV8Context.set(this.getScriptIsolateId(data.isolate, data.scriptId), data.v8context);
-                this.#scriptToFrame.set(this.getScriptIsolateId(data.isolate, data.scriptId), data.frame);
-                // All the targets should've been added by the TracingStartedInBrowser event, but just in case we're missing some there
-                const frameId = data.frame;
-                if (!this.#targets.find(target => target.targetId === frameId)) {
-                    this.#targets.push({
-                        targetId: frameId,
-                        type: data.frameType,
-                        isolate: String(data.isolate),
-                        pid: event.pid,
-                        url: data.url,
-                    });
-                }
-                // Add execution context, need to put back execution context id with info from other traces
-                if (!this.#executionContexts.find(executionContext => executionContext.v8Context === data.v8context)) {
-                    this.#executionContexts.push({
-                        id: -1,
-                        origin: data.origin,
-                        v8Context: data.v8context,
-                        auxData: {
-                            frameId: data.frame,
-                            isDefault: data.isDefault,
-                            type: data.contextType,
-                        },
-                        isolate: String(data.isolate),
-                        name: data.origin,
-                        uniqueId: `${data.v8context}-${data.isolate}`,
-                    });
-                }
-            }
-            else if (this.isRundownScript(event)) {
-                this.#scriptRundownEvents.push(event);
-                const data = event.args.data;
-                // Add script
-                if (!this.#scripts.find(script => script.scriptId === String(data.scriptId) && script.isolate === String(data.isolate))) {
-                    this.#scripts.push({
-                        scriptId: String(data.scriptId),
-                        isolate: String(data.isolate),
-                        buildId: '',
-                        executionContextId: data.executionContextId,
-                        startLine: data.startLine ?? 0,
-                        startColumn: data.startColumn ?? 0,
-                        endLine: data.endLine ?? 0,
-                        endColumn: data.endColumn ?? 0,
-                        hash: data.hash ?? '',
-                        isModule: data.isModule,
-                        url: data.url ?? '',
-                        hasSourceURL: data.hasSourceUrl,
-                        sourceURL: data.sourceUrl ?? '',
-                        sourceMapURL: data.sourceMapUrl,
-                        pid: event.pid,
-                    });
-                }
-            }
-            else if (this.isRundownScriptSource(event)) {
-                // Set up script to source text and length mapping
-                const data = event.args.data;
-                const scriptIsolateId = this.getScriptIsolateId(data.isolate, data.scriptId);
-                if ('splitIndex' in data && 'splitCount' in data) {
-                    if (!this.#largeScriptToScriptSource.has(scriptIsolateId)) {
-                        this.#largeScriptToScriptSource.set(scriptIsolateId, new Array(data.splitCount).fill(''));
-                    }
-                    const splittedSource = this.#largeScriptToScriptSource.get(scriptIsolateId);
-                    if (splittedSource && data.sourceText) {
-                        splittedSource[data.splitIndex] = data.sourceText;
-                    }
-                }
-                else {
-                    if (data.sourceText) {
-                        this.#scriptToScriptSource.set(scriptIsolateId, data.sourceText);
-                    }
-                    if (data.length) {
-                        this.#scriptToSourceLength.set(scriptIsolateId, data.length);
-                    }
-                }
-            }
-        }
-    }
-    data() {
-        // Put back execution context id
-        const v8ContextToExecutionContextId = new Map();
-        this.#scriptRundownEvents.forEach(scriptRundownEvent => {
-            const data = scriptRundownEvent.args.data;
-            const v8Context = this.#scriptToV8Context.get(this.getScriptIsolateId(data.isolate, data.scriptId));
-            if (v8Context) {
-                v8ContextToExecutionContextId.set(v8Context, data.executionContextId);
-            }
-        });
-        this.#executionContexts.forEach(executionContext => {
-            if (executionContext.v8Context) {
-                const id = v8ContextToExecutionContextId.get(executionContext.v8Context);
-                if (id) {
-                    executionContext.id = id;
-                }
-            }
-        });
-        // Put back script source text and length
-        this.#scripts.forEach(script => {
-            const scriptIsolateId = this.getScriptIsolateId(script.isolate, script.scriptId);
-            if (this.#scriptToScriptSource.has(scriptIsolateId)) {
-                script.sourceText = this.#scriptToScriptSource.get(scriptIsolateId);
-                script.length = this.#scriptToSourceLength.get(scriptIsolateId);
-            }
-            else if (this.#largeScriptToScriptSource.has(scriptIsolateId)) {
-                const splittedSources = this.#largeScriptToScriptSource.get(scriptIsolateId);
-                if (splittedSources) {
-                    script.sourceText = splittedSources.join('');
-                    script.length = script.sourceText.length;
-                }
-            }
-            // put in the aux data
-            const linkedExecutionContext = this.#executionContexts.find(context => context.id === script.executionContextId && context.isolate === script.isolate);
-            if (linkedExecutionContext) {
-                script.executionContextAuxData = linkedExecutionContext.auxData;
-                // If a script successfully mapped to an execution context and aux data, link script to frame
-                if (script.executionContextAuxData?.frameId) {
-                    this.#scriptToFrame.set(scriptIsolateId, script.executionContextAuxData?.frameId);
-                }
-            }
-        });
-        for (const script of this.#scripts) {
-            // Resolve the source map from the provided metadata.
-            // If no map is found for a given source map url, no source map is passed to the debugger model.
-            // Encoded as a data url so that the debugger model makes no network request.
-            // NOTE: consider passing directly as object and hacking `parsedScriptSource` in DebuggerModel.ts to handle
-            // this fake event. Would avoid a lot of wasteful (de)serialization. Maybe add SDK.Script.hydratedSourceMap.
-            this.resolveSourceMap(script);
-        }
-        this.#resources = this.#trace.metadata.resources ?? [];
-        return this.groupContextsAndScriptsUnderTarget(this.#targets, this.#executionContexts, this.#scripts, this.#resources);
-    }
-    resolveSourceMap(script) {
-        if (script.sourceMapURL?.startsWith('data:')) {
-            return;
-        }
-        const sourceMap = this.getSourceMapFromMetadata(script);
-        if (!sourceMap) {
-            return;
-        }
-        // Note: this encoding + re-parsing overhead cost ~10ms per 1MB of JSON on my
-        // Mac M1 Pro.
-        // See https://crrev.com/c/6490409/comments/f294c12a_69781e24
-        const payload = encodeURIComponent(JSON.stringify(sourceMap));
-        script.sourceMapURL = `data:application/json;charset=utf-8,${payload}`;
-    }
-    getSourceMapFromMetadata(script) {
-        const { hasSourceURL, sourceURL, url, sourceMapURL, isolate, scriptId } = script;
-        if (!sourceMapURL || !this.#trace.metadata.sourceMaps) {
-            return;
-        }
-        const frame = this.#scriptToFrame.get(this.getScriptIsolateId(isolate, scriptId));
-        if (!frame) {
-            return;
-        }
-        const target = this.#targets.find(t => t.targetId === frame);
-        if (!target) {
-            return;
-        }
-        let resolvedSourceUrl = url;
-        if (hasSourceURL && sourceURL) {
-            const targetUrl = target.url;
-            resolvedSourceUrl = Common.ParsedURL.ParsedURL.completeURL(targetUrl, sourceURL) ?? sourceURL;
-        }
-        // Resolve the source map url. The value given by v8 may be relative, so resolve it here.
-        // This process should match the one in `SourceMapManager.attachSourceMap`.
-        const resolvedSourceMapUrl = Common.ParsedURL.ParsedURL.completeURL(resolvedSourceUrl, sourceMapURL);
-        if (!resolvedSourceMapUrl) {
-            return;
-        }
-        const { sourceMap } = this.#trace.metadata.sourceMaps.find(m => m.sourceMapUrl === resolvedSourceMapUrl) ?? {};
-        return sourceMap;
-    }
-    getScriptIsolateId(isolate, scriptId) {
-        return `${scriptId}@${isolate}`;
-    }
-    getExecutionContextIsolateId(isolate, executionContextId) {
-        return `${executionContextId}@${isolate}`;
-    }
-    isTraceEvent(event) {
-        return 'cat' in event && 'pid' in event && 'args' in event &&
-            'data' in event.args;
-    }
-    isRundownScriptCompiled(event) {
-        return this.isTraceEvent(event) && event.cat === 'disabled-by-default-devtools.target-rundown';
-    }
-    isRundownScript(event) {
-        return this.isTraceEvent(event) && event.cat === 'disabled-by-default-devtools.v8-source-rundown';
-    }
-    isRundownScriptSource(event) {
-        return this.isTraceEvent(event) && event.cat === 'disabled-by-default-devtools.v8-source-rundown-sources';
-    }
-    isTracingStartedInBrowser(event) {
-        return this.isTraceEvent(event) && event.cat === 'disabled-by-default-devtools.timeline' &&
-            event.name === 'TracingStartedInBrowser';
-    }
-    isFunctionCallEvent(event) {
-        return this.isTraceEvent(event) && event.cat === 'devtools.timeline' && event.name === 'FunctionCall';
-    }
-    groupContextsAndScriptsUnderTarget(targets, executionContexts, scripts, resources) {
-        const data = [];
-        const targetIds = new Set();
-        const targetToExecutionContexts = new Map();
-        // We want to keep track of how each execution context is linked to targets so we may use this
-        // information to link scripts with no target to a target
-        const executionContextIsolateToTarget = new Map();
-        const targetToScripts = new Map();
-        const orphanScripts = [];
-        const targetToResources = new Map();
-        // Initialize all the mapping needed
-        for (const target of targets) {
-            targetIds.add(target.targetId);
-            targetToExecutionContexts.set(target.targetId, []);
-            targetToScripts.set(target.targetId, []);
-            targetToResources.set(target.targetId, []);
-        }
-        // Put all of the known execution contexts under respective targets
-        for (const executionContext of executionContexts) {
-            const frameId = executionContext.auxData?.frameId;
-            if (frameId && targetIds.has(frameId)) {
-                targetToExecutionContexts.get(frameId)?.push(executionContext);
-                executionContextIsolateToTarget.set(this.getExecutionContextIsolateId(executionContext.isolate, executionContext.id), frameId);
-            }
-            else {
-                console.error('Execution context can\'t be linked to a target', executionContext);
-            }
-        }
-        // Put all of the scripts under respective targets with collected information
-        for (const script of scripts) {
-            const scriptExecutionContextIsolateId = this.getExecutionContextIsolateId(script.isolate, script.executionContextId);
-            const scriptFrameId = script.executionContextAuxData?.frameId;
-            if (script.executionContextAuxData?.frameId && targetIds.has(scriptFrameId)) {
-                targetToScripts.get(scriptFrameId)?.push(script);
-                executionContextIsolateToTarget.set(scriptExecutionContextIsolateId, scriptFrameId);
-            }
-            else if (this.#scriptToFrame.has(this.getScriptIsolateId(script.isolate, script.scriptId))) {
-                const targetId = this.#scriptToFrame.get(this.getScriptIsolateId(script.isolate, script.scriptId));
-                if (targetId) {
-                    targetToScripts.get(targetId)?.push(script);
-                    executionContextIsolateToTarget.set(scriptExecutionContextIsolateId, targetId);
-                }
-            }
-            else {
-                // These scripts are not linked to any target
-                orphanScripts.push(script);
-            }
-        }
-        // If a script is not linked to a target, use executionContext@isolate to link to a target
-        // Using PID is the last resort
-        for (const orphanScript of orphanScripts) {
-            const orphanScriptExecutionContextIsolateId = this.getExecutionContextIsolateId(orphanScript.isolate, orphanScript.executionContextId);
-            const frameId = executionContextIsolateToTarget.get(orphanScriptExecutionContextIsolateId);
-            if (frameId) {
-                // Found a link via execution context, use it.
-                targetToScripts.get(frameId)?.push(orphanScript);
-            }
-            else if (orphanScript.pid) {
-                const target = targets.find(target => target.pid === orphanScript.pid);
-                if (target) {
-                    targetToScripts.get(target.targetId)?.push(orphanScript);
-                }
-            }
-            else {
-                console.error('Script can\'t be linked to any target', orphanScript);
-            }
-        }
-        for (const resource of resources) {
-            const frameId = resource.frame;
-            if (targetIds.has(frameId)) {
-                targetToResources.get(frameId)?.push(resource);
-            }
-        }
-        // Now all the scripts are linked to a target, we want to make sure all the scripts are pointing to a valid
-        // execution context. If not, we will create an artificial execution context for the script
-        for (const target of targets) {
-            const targetId = target.targetId;
-            const executionContexts = targetToExecutionContexts.get(targetId) || [];
-            const scripts = targetToScripts.get(targetId) || [];
-            const resources = targetToResources.get(targetId) || [];
-            for (const script of scripts) {
-                if (!executionContexts.find(context => context.id === script.executionContextId)) {
-                    const artificialContext = {
-                        id: script.executionContextId,
-                        origin: '',
-                        v8Context: '',
-                        name: '',
-                        auxData: {
-                            frameId: targetId,
-                            isDefault: false,
-                            type: 'type',
-                        },
-                        isolate: script.isolate,
-                        uniqueId: `${targetId}-${script.isolate}`,
-                    };
-                    executionContexts.push(artificialContext);
-                }
-            }
-            // Finally, we put all the information into the data structure we want to return as.
-            data.push({ target, executionContexts, scripts, resources });
-        }
-        return data;
-    }
-}

package/build/vendor/chrome-devtools-frontend/front_end/core/sdk/EventBreakpointsModel.js

@@ -1,127 +0,0 @@
-// Copyright 2021 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-import { CategorizedBreakpoint } from './CategorizedBreakpoint.js';
-import { SDKModel } from './SDKModel.js';
-import { TargetManager } from './TargetManager.js';
-export class EventBreakpointsModel extends SDKModel {
-    agent;
-    constructor(target) {
-        super(target);
-        this.agent = target.eventBreakpointsAgent();
-    }
-}
-/**
- * This implementation (as opposed to similar class in DOMDebuggerModel) is for
- * instrumentation breakpoints in targets that run JS but do not have a DOM.
- **/
-class EventListenerBreakpoint extends CategorizedBreakpoint {
-    setEnabled(enabled) {
-        if (this.enabled() === enabled) {
-            return;
-        }
-        super.setEnabled(enabled);
-        for (const model of TargetManager.instance().models(EventBreakpointsModel)) {
-            this.updateOnModel(model);
-        }
-    }
-    updateOnModel(model) {
-        if (this.enabled()) {
-            void model.agent.invoke_setInstrumentationBreakpoint({ eventName: this.name });
-        }
-        else {
-            void model.agent.invoke_removeInstrumentationBreakpoint({ eventName: this.name });
-        }
-    }
-    static instrumentationPrefix = 'instrumentation:';
-}
-let eventBreakpointManagerInstance;
-export class EventBreakpointsManager {
-    #eventListenerBreakpoints = [];
-    constructor() {
-        this.createInstrumentationBreakpoints("auction-worklet" /* Category.AUCTION_WORKLET */, [
-            "beforeBidderWorkletBiddingStart" /* InstrumentationNames.BEFORE_BIDDER_WORKLET_BIDDING_START */,
-            "beforeBidderWorkletReportingStart" /* InstrumentationNames.BEFORE_BIDDER_WORKLET_REPORTING_START */,
-            "beforeSellerWorkletScoringStart" /* InstrumentationNames.BEFORE_SELLER_WORKLET_SCORING_START */,
-            "beforeSellerWorkletReportingStart" /* InstrumentationNames.BEFORE_SELLER_WORKLET_REPORTING_START */,
-        ]);
-        this.createInstrumentationBreakpoints("animation" /* Category.ANIMATION */, [
-            "requestAnimationFrame" /* InstrumentationNames.REQUEST_ANIMATION_FRAME */,
-            "cancelAnimationFrame" /* InstrumentationNames.CANCEL_ANIMATION_FRAME */,
-            "requestAnimationFrame.callback" /* InstrumentationNames.REQUEST_ANIMATION_FRAME_CALLBACK */,
-        ]);
-        this.createInstrumentationBreakpoints("canvas" /* Category.CANVAS */, [
-            "canvasContextCreated" /* InstrumentationNames.CANVAS_CONTEXT_CREATED */,
-            "webglErrorFired" /* InstrumentationNames.WEBGL_ERROR_FIRED */,
-            "webglWarningFired" /* InstrumentationNames.WEBGL_WARNING_FIRED */,
-        ]);
-        this.createInstrumentationBreakpoints("geolocation" /* Category.GEOLOCATION */, [
-            "Geolocation.getCurrentPosition" /* InstrumentationNames.GEOLOCATION_GET_CURRENT_POSITION */,
-            "Geolocation.watchPosition" /* InstrumentationNames.GEOLOCATION_WATCH_POSITION */,
-        ]);
-        this.createInstrumentationBreakpoints("notification" /* Category.NOTIFICATION */, [
-            "Notification.requestPermission" /* InstrumentationNames.NOTIFICATION_REQUEST_PERMISSION */,
-        ]);
-        this.createInstrumentationBreakpoints("parse" /* Category.PARSE */, [
-            "Element.setInnerHTML" /* InstrumentationNames.ELEMENT_SET_INNER_HTML */,
-            "Document.write" /* InstrumentationNames.DOCUMENT_WRITE */,
-        ]);
-        this.createInstrumentationBreakpoints("script" /* Category.SCRIPT */, [
-            "scriptFirstStatement" /* InstrumentationNames.SCRIPT_FIRST_STATEMENT */,
-            "scriptBlockedByCSP" /* InstrumentationNames.SCRIPT_BLOCKED_BY_CSP */,
-        ]);
-        this.createInstrumentationBreakpoints("shared-storage-worklet" /* Category.SHARED_STORAGE_WORKLET */, [
-            "sharedStorageWorkletScriptFirstStatement" /* InstrumentationNames.SHARED_STORAGE_WORKLET_SCRIPT_FIRST_STATEMENT */,
-        ]);
-        this.createInstrumentationBreakpoints("timer" /* Category.TIMER */, [
-            "setTimeout" /* InstrumentationNames.SET_TIMEOUT */,
-            "clearTimeout" /* InstrumentationNames.CLEAR_TIMEOUT */,
-            "setTimeout.callback" /* InstrumentationNames.SET_TIMEOUT_CALLBACK */,
-            "setInterval" /* InstrumentationNames.SET_INTERVAL */,
-            "clearInterval" /* InstrumentationNames.CLEAR_INTERVAL */,
-            "setInterval.callback" /* InstrumentationNames.SET_INTERVAL_CALLBACK */,
-        ]);
-        this.createInstrumentationBreakpoints("window" /* Category.WINDOW */, [
-            "DOMWindow.close" /* InstrumentationNames.DOM_WINDOW_CLOSE */,
-        ]);
-        this.createInstrumentationBreakpoints("web-audio" /* Category.WEB_AUDIO */, [
-            "audioContextCreated" /* InstrumentationNames.AUDIO_CONTEXT_CREATED */,
-            "audioContextClosed" /* InstrumentationNames.AUDIO_CONTEXT_CLOSED */,
-            "audioContextResumed" /* InstrumentationNames.AUDIO_CONTEXT_RESUMED */,
-            "audioContextSuspended" /* InstrumentationNames.AUDIO_CONTEXT_SUSPENDED */,
-        ]);
-        TargetManager.instance().observeModels(EventBreakpointsModel, this);
-    }
-    static instance(opts = { forceNew: null }) {
-        const { forceNew } = opts;
-        if (!eventBreakpointManagerInstance || forceNew) {
-            eventBreakpointManagerInstance = new EventBreakpointsManager();
-        }
-        return eventBreakpointManagerInstance;
-    }
-    createInstrumentationBreakpoints(category, instrumentationNames) {
-        for (const instrumentationName of instrumentationNames) {
-            this.#eventListenerBreakpoints.push(new EventListenerBreakpoint(category, instrumentationName));
-        }
-    }
-    eventListenerBreakpoints() {
-        return this.#eventListenerBreakpoints.slice();
-    }
-    resolveEventListenerBreakpoint({ eventName }) {
-        if (!eventName.startsWith(EventListenerBreakpoint.instrumentationPrefix)) {
-            return null;
-        }
-        const instrumentationName = eventName.substring(EventListenerBreakpoint.instrumentationPrefix.length);
-        return this.#eventListenerBreakpoints.find(b => b.name === instrumentationName) || null;
-    }
-    modelAdded(eventBreakpointModel) {
-        for (const breakpoint of this.#eventListenerBreakpoints) {
-            if (breakpoint.enabled()) {
-                breakpoint.updateOnModel(eventBreakpointModel);
-            }
-        }
-    }
-    modelRemoved(_eventBreakpointModel) {
-    }
-}
-SDKModel.register(EventBreakpointsModel, { capabilities: 524288 /* Capability.EVENT_BREAKPOINTS */, autostart: false });

package/build/vendor/chrome-devtools-frontend/front_end/core/sdk/FrameAssociated.js

@@ -1,4 +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.
-export {};