chrome-devtools-mcp 0.0.1 → 0.0.2

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

@@ -0,0 +1,300 @@
+// 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 Common from '../common/common.js';
+import * as Host from '../host/host.js';
+import * as i18n from '../i18n/i18n.js';
+import { FrameManager } from './FrameManager.js';
+import { IOModel } from './IOModel.js';
+import { MultitargetNetworkManager, NetworkManager } from './NetworkManager.js';
+import { Events as ResourceTreeModelEvents, ResourceTreeModel, } from './ResourceTreeModel.js';
+import { TargetManager } from './TargetManager.js';
+const UIStrings = {
+    /**
+     * @description Error message for canceled source map loads
+     */
+    loadCanceledDueToReloadOf: 'Load canceled due to reload of inspected page',
+};
+const str_ = i18n.i18n.registerUIStrings('core/sdk/PageResourceLoader.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+function isExtensionInitiator(initiator) {
+    return 'extensionId' in initiator;
+}
+// Used for revealing a resource.
+export class ResourceKey {
+    key;
+    constructor(key) {
+        this.key = key;
+    }
+}
+let pageResourceLoader = null;
+/**
+ * The page resource loader is a bottleneck for all DevTools-initiated resource loads. For each such load, it keeps a
+ * `PageResource` object around that holds meta information. This can be as the basis for reporting to the user which
+ * resources were loaded, and whether there was a load error.
+ */
+export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
+    #currentlyLoading = 0;
+    #currentlyLoadingPerTarget = new Map();
+    #maxConcurrentLoads;
+    #pageResources = new Map();
+    #queuedLoads = [];
+    #loadOverride;
+    constructor(loadOverride, maxConcurrentLoads) {
+        super();
+        this.#maxConcurrentLoads = maxConcurrentLoads;
+        TargetManager.instance().addModelListener(ResourceTreeModel, ResourceTreeModelEvents.PrimaryPageChanged, this.onPrimaryPageChanged, this);
+        this.#loadOverride = loadOverride;
+    }
+    static instance({ forceNew, loadOverride, maxConcurrentLoads } = {
+        forceNew: false,
+        loadOverride: null,
+        maxConcurrentLoads: 500,
+    }) {
+        if (!pageResourceLoader || forceNew) {
+            pageResourceLoader = new PageResourceLoader(loadOverride, maxConcurrentLoads);
+        }
+        return pageResourceLoader;
+    }
+    static removeInstance() {
+        pageResourceLoader = null;
+    }
+    onPrimaryPageChanged(event) {
+        const { frame: mainFrame, type } = event.data;
+        if (!mainFrame.isOutermostFrame()) {
+            return;
+        }
+        for (const { reject } of this.#queuedLoads) {
+            reject(new Error(i18nString(UIStrings.loadCanceledDueToReloadOf)));
+        }
+        this.#queuedLoads = [];
+        const mainFrameTarget = mainFrame.resourceTreeModel().target();
+        const keptResources = new Map();
+        // If the navigation is a prerender-activation, the pageResources for the destination page have
+        // already been preloaded. In such cases, we therefore don't just discard all pageResources, but
+        // instead make sure to keep the pageResources for the prerendered target.
+        for (const [key, pageResource] of this.#pageResources.entries()) {
+            if ((type === "Activation" /* PrimaryPageChangeType.ACTIVATION */) && mainFrameTarget === pageResource.initiator.target) {
+                keptResources.set(key, pageResource);
+            }
+        }
+        this.#pageResources = keptResources;
+        this.dispatchEventToListeners("Update" /* Events.UPDATE */);
+    }
+    getResourcesLoaded() {
+        return this.#pageResources;
+    }
+    getScopedResourcesLoaded() {
+        return new Map([...this.#pageResources].filter(([_, pageResource]) => TargetManager.instance().isInScope(pageResource.initiator.target) ||
+            isExtensionInitiator(pageResource.initiator)));
+    }
+    /**
+     * Loading is the number of currently loading and queued items. Resources is the total number of resources,
+     * including loading and queued resources, but not including resources that are still loading but scheduled
+     * for cancelation.;
+     */
+    getNumberOfResources() {
+        return { loading: this.#currentlyLoading, queued: this.#queuedLoads.length, resources: this.#pageResources.size };
+    }
+    getScopedNumberOfResources() {
+        const targetManager = TargetManager.instance();
+        let loadingCount = 0;
+        for (const [targetId, count] of this.#currentlyLoadingPerTarget) {
+            const target = targetManager.targetById(targetId);
+            if (targetManager.isInScope(target)) {
+                loadingCount += count;
+            }
+        }
+        return { loading: loadingCount, resources: this.getScopedResourcesLoaded().size };
+    }
+    async acquireLoadSlot(target) {
+        this.#currentlyLoading++;
+        if (target) {
+            const currentCount = this.#currentlyLoadingPerTarget.get(target.id()) || 0;
+            this.#currentlyLoadingPerTarget.set(target.id(), currentCount + 1);
+        }
+        if (this.#currentlyLoading > this.#maxConcurrentLoads) {
+            const { promise: waitForCapacity, resolve, reject, } = Promise.withResolvers();
+            this.#queuedLoads.push({ resolve, reject });
+            await waitForCapacity;
+        }
+    }
+    releaseLoadSlot(target) {
+        this.#currentlyLoading--;
+        if (target) {
+            const currentCount = this.#currentlyLoadingPerTarget.get(target.id());
+            if (currentCount) {
+                this.#currentlyLoadingPerTarget.set(target.id(), currentCount - 1);
+            }
+        }
+        const entry = this.#queuedLoads.shift();
+        if (entry) {
+            entry.resolve();
+        }
+    }
+    static makeExtensionKey(url, initiator) {
+        if (isExtensionInitiator(initiator) && initiator.extensionId) {
+            return `${url}-${initiator.extensionId}`;
+        }
+        throw new Error('Invalid initiator');
+    }
+    static makeKey(url, initiator) {
+        if (initiator.frameId) {
+            return `${url}-${initiator.frameId}`;
+        }
+        if (initiator.target) {
+            return `${url}-${initiator.target.id()}`;
+        }
+        throw new Error('Invalid initiator');
+    }
+    resourceLoadedThroughExtension(pageResource) {
+        const key = PageResourceLoader.makeExtensionKey(pageResource.url, pageResource.initiator);
+        this.#pageResources.set(key, pageResource);
+        this.dispatchEventToListeners("Update" /* Events.UPDATE */);
+    }
+    async loadResource(url, initiator, isBinary = false) {
+        if (isExtensionInitiator(initiator)) {
+            throw new Error('Invalid initiator');
+        }
+        const key = PageResourceLoader.makeKey(url, initiator);
+        const pageResource = { success: null, size: null, duration: null, errorMessage: undefined, url, initiator };
+        this.#pageResources.set(key, pageResource);
+        this.dispatchEventToListeners("Update" /* Events.UPDATE */);
+        const startTime = performance.now();
+        try {
+            await this.acquireLoadSlot(initiator.target);
+            const resultPromise = this.dispatchLoad(url, initiator, isBinary);
+            const result = await resultPromise;
+            pageResource.errorMessage = result.errorDescription.message;
+            pageResource.success = result.success;
+            if (result.success) {
+                pageResource.size = result.content.length;
+                return { content: result.content };
+            }
+            throw new Error(result.errorDescription.message);
+        }
+        catch (e) {
+            if (pageResource.errorMessage === undefined) {
+                pageResource.errorMessage = e.message;
+            }
+            if (pageResource.success === null) {
+                pageResource.success = false;
+            }
+            throw e;
+        }
+        finally {
+            pageResource.duration = performance.now() - startTime;
+            this.releaseLoadSlot(initiator.target);
+            this.dispatchEventToListeners("Update" /* Events.UPDATE */);
+        }
+    }
+    async dispatchLoad(url, initiator, isBinary) {
+        if (isExtensionInitiator(initiator)) {
+            throw new Error('Invalid initiator');
+        }
+        const failureReason = null;
+        if (this.#loadOverride) {
+            return await this.#loadOverride(url);
+        }
+        const parsedURL = new Common.ParsedURL.ParsedURL(url);
+        const eligibleForLoadFromTarget = getLoadThroughTargetSetting().get() && parsedURL && parsedURL.scheme !== 'file' &&
+            parsedURL.scheme !== 'data' && parsedURL.scheme !== 'devtools';
+        Host.userMetrics.developerResourceScheme(this.getDeveloperResourceScheme(parsedURL));
+        if (eligibleForLoadFromTarget) {
+            try {
+                if (initiator.target) {
+                    Host.userMetrics.developerResourceLoaded(0 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_TARGET */);
+                    const result = await this.loadFromTarget(initiator.target, initiator.frameId, url, isBinary);
+                    return result;
+                }
+                const frame = FrameManager.instance().getFrame(initiator.frameId);
+                if (frame) {
+                    Host.userMetrics.developerResourceLoaded(1 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_FRAME */);
+                    const result = await this.loadFromTarget(frame.resourceTreeModel().target(), initiator.frameId, url, isBinary);
+                    return result;
+                }
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    Host.userMetrics.developerResourceLoaded(2 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_FAILURE */);
+                    if (e.message.includes('CSP violation')) {
+                        return {
+                            success: false,
+                            content: '',
+                            errorDescription: { statusCode: 0, netError: undefined, netErrorName: undefined, message: e.message, urlValid: undefined }
+                        };
+                    }
+                }
+            }
+            Host.userMetrics.developerResourceLoaded(3 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_FALLBACK */);
+        }
+        else {
+            const code = getLoadThroughTargetSetting().get() ?
+                6 /* Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_PER_PROTOCOL */ :
+                5 /* Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_PER_OVERRIDE */;
+            Host.userMetrics.developerResourceLoaded(code);
+        }
+        const result = await MultitargetNetworkManager.instance().loadResource(url);
+        if (eligibleForLoadFromTarget && !result.success) {
+            Host.userMetrics.developerResourceLoaded(7 /* Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_FAILURE */);
+        }
+        if (failureReason) {
+            // In case we have a success, add a note about why the load through the target failed.
+            result.errorDescription.message =
+                `Fetch through target failed: ${failureReason}; Fallback: ${result.errorDescription.message}`;
+        }
+        return result;
+    }
+    getDeveloperResourceScheme(parsedURL) {
+        if (!parsedURL || parsedURL.scheme === '') {
+            return 1 /* Host.UserMetrics.DeveloperResourceScheme.UKNOWN */;
+        }
+        const isLocalhost = parsedURL.host === 'localhost' || parsedURL.host.endsWith('.localhost');
+        switch (parsedURL.scheme) {
+            case 'file':
+                return 7 /* Host.UserMetrics.DeveloperResourceScheme.FILE */;
+            case 'data':
+                return 6 /* Host.UserMetrics.DeveloperResourceScheme.DATA */;
+            case 'blob':
+                return 8 /* Host.UserMetrics.DeveloperResourceScheme.BLOB */;
+            case 'http':
+                return isLocalhost ? 4 /* Host.UserMetrics.DeveloperResourceScheme.HTTP_LOCALHOST */ :
+                    2 /* Host.UserMetrics.DeveloperResourceScheme.HTTP */;
+            case 'https':
+                return isLocalhost ? 5 /* Host.UserMetrics.DeveloperResourceScheme.HTTPS_LOCALHOST */ :
+                    3 /* Host.UserMetrics.DeveloperResourceScheme.HTTPS */;
+        }
+        return 0 /* Host.UserMetrics.DeveloperResourceScheme.OTHER */;
+    }
+    async loadFromTarget(target, frameId, url, isBinary) {
+        const networkManager = target.model(NetworkManager);
+        const ioModel = target.model(IOModel);
+        const disableCache = Common.Settings.Settings.instance().moduleSetting('cache-disabled').get();
+        const resource = await networkManager.loadNetworkResource(frameId, url, { disableCache, includeCredentials: true });
+        try {
+            const content = resource.stream ?
+                (isBinary ? await ioModel.readToBuffer(resource.stream) : await ioModel.readToString(resource.stream)) :
+                '';
+            return {
+                success: resource.success,
+                content,
+                errorDescription: {
+                    statusCode: resource.httpStatusCode || 0,
+                    netError: resource.netError,
+                    netErrorName: resource.netErrorName,
+                    message: Host.ResourceLoader.netErrorToMessage(resource.netError, resource.httpStatusCode, resource.netErrorName) ||
+                        '',
+                    urlValid: undefined,
+                },
+            };
+        }
+        finally {
+            if (resource.stream) {
+                void ioModel.close(resource.stream);
+            }
+        }
+    }
+}
+export function getLoadThroughTargetSetting() {
+    return Common.Settings.Settings.instance().createSetting('load-through-target', true);
+}

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

@@ -0,0 +1,67 @@
+// Copyright 2013 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { SDKModel } from './SDKModel.js';
+export class PaintProfilerModel extends SDKModel {
+    layerTreeAgent;
+    constructor(target) {
+        super(target);
+        this.layerTreeAgent = target.layerTreeAgent();
+    }
+    async loadSnapshotFromFragments(tiles) {
+        const { snapshotId } = await this.layerTreeAgent.invoke_loadSnapshot({ tiles });
+        return snapshotId ? new PaintProfilerSnapshot(this, snapshotId) : null;
+    }
+    loadSnapshot(encodedPicture) {
+        const fragment = { x: 0, y: 0, picture: encodedPicture };
+        return this.loadSnapshotFromFragments([fragment]);
+    }
+    async makeSnapshot(layerId) {
+        const { snapshotId } = await this.layerTreeAgent.invoke_makeSnapshot({ layerId });
+        return snapshotId ? new PaintProfilerSnapshot(this, snapshotId) : null;
+    }
+}
+export class PaintProfilerSnapshot {
+    #paintProfilerModel;
+    #id;
+    #refCount;
+    constructor(paintProfilerModel, snapshotId) {
+        this.#paintProfilerModel = paintProfilerModel;
+        this.#id = snapshotId;
+        this.#refCount = 1;
+    }
+    release() {
+        console.assert(this.#refCount > 0, 'release is already called on the object');
+        if (!--this.#refCount) {
+            void this.#paintProfilerModel.layerTreeAgent.invoke_releaseSnapshot({ snapshotId: this.#id });
+        }
+    }
+    addReference() {
+        ++this.#refCount;
+        console.assert(this.#refCount > 0, 'Referencing a dead object');
+    }
+    async replay(scale, fromStep, toStep) {
+        const response = await this.#paintProfilerModel.layerTreeAgent.invoke_replaySnapshot({ snapshotId: this.#id, fromStep, toStep, scale: scale || 1.0 });
+        return response.dataURL;
+    }
+    async profile(clipRect) {
+        const response = await this.#paintProfilerModel.layerTreeAgent.invoke_profileSnapshot({ snapshotId: this.#id, minRepeatCount: 5, minDuration: 1, clipRect: clipRect || undefined });
+        return response.timings;
+    }
+    async commandLog() {
+        const response = await this.#paintProfilerModel.layerTreeAgent.invoke_snapshotCommandLog({ snapshotId: this.#id });
+        return response.commandLog ? response.commandLog.map((entry, index) => new PaintProfilerLogItem(entry, index)) :
+            null;
+    }
+}
+export class PaintProfilerLogItem {
+    method;
+    params;
+    commandIndex;
+    constructor(rawEntry, commandIndex) {
+        this.method = rawEntry.method;
+        this.params = rawEntry.params;
+        this.commandIndex = commandIndex;
+    }
+}
+SDKModel.register(PaintProfilerModel, { capabilities: 2 /* Capability.DOM */, autostart: false });

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

@@ -0,0 +1,62 @@
+// Copyright 2017 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 Platform from '../platform/platform.js';
+import { SDKModel } from './SDKModel.js';
+export class PerformanceMetricsModel extends SDKModel {
+    #agent;
+    #metricModes = new Map([
+        ['TaskDuration', "CumulativeTime" /* MetricMode.CUMULATIVE_TIME */],
+        ['ScriptDuration', "CumulativeTime" /* MetricMode.CUMULATIVE_TIME */],
+        ['LayoutDuration', "CumulativeTime" /* MetricMode.CUMULATIVE_TIME */],
+        ['RecalcStyleDuration', "CumulativeTime" /* MetricMode.CUMULATIVE_TIME */],
+        ['LayoutCount', "CumulativeCount" /* MetricMode.CUMULATIVE_COUNT */],
+        ['RecalcStyleCount', "CumulativeCount" /* MetricMode.CUMULATIVE_COUNT */],
+    ]);
+    #metricData = new Map();
+    constructor(target) {
+        super(target);
+        this.#agent = target.performanceAgent();
+    }
+    enable() {
+        return this.#agent.invoke_enable({});
+    }
+    disable() {
+        return this.#agent.invoke_disable();
+    }
+    async requestMetrics() {
+        const rawMetrics = await this.#agent.invoke_getMetrics() || [];
+        const metrics = new Map();
+        const timestamp = performance.now();
+        for (const metric of rawMetrics.metrics) {
+            let data = this.#metricData.get(metric.name);
+            if (!data) {
+                data = { lastValue: undefined, lastTimestamp: undefined };
+                this.#metricData.set(metric.name, data);
+            }
+            let value;
+            switch (this.#metricModes.get(metric.name)) {
+                case "CumulativeTime" /* MetricMode.CUMULATIVE_TIME */:
+                    value = (data.lastTimestamp && data.lastValue) ?
+                        Platform.NumberUtilities.clamp((metric.value - data.lastValue) * 1000 / (timestamp - data.lastTimestamp), 0, 1) :
+                        0;
+                    data.lastValue = metric.value;
+                    data.lastTimestamp = timestamp;
+                    break;
+                case "CumulativeCount" /* MetricMode.CUMULATIVE_COUNT */:
+                    value = (data.lastTimestamp && data.lastValue) ?
+                        Math.max(0, (metric.value - data.lastValue) * 1000 / (timestamp - data.lastTimestamp)) :
+                        0;
+                    data.lastValue = metric.value;
+                    data.lastTimestamp = timestamp;
+                    break;
+                default:
+                    value = metric.value;
+                    break;
+            }
+            metrics.set(metric.name, value);
+        }
+        return { metrics, timestamp };
+    }
+}
+SDKModel.register(PerformanceMetricsModel, { capabilities: 2 /* Capability.DOM */, autostart: false });