@nimbus21.ai/chrome-devtools-mcp 0.6.1

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

@@ -0,0 +1,130 @@
+// 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 { RuntimeModel } from './RuntimeModel.js';
+import { SDKModel } from './SDKModel.js';
+export class HeapProfilerModel extends SDKModel {
+    #enabled;
+    #heapProfilerAgent;
+    #runtimeModel;
+    #samplingProfilerDepth;
+    constructor(target) {
+        super(target);
+        target.registerHeapProfilerDispatcher(new HeapProfilerDispatcher(this));
+        this.#enabled = false;
+        this.#heapProfilerAgent = target.heapProfilerAgent();
+        this.#runtimeModel = target.model(RuntimeModel);
+        this.#samplingProfilerDepth = 0;
+    }
+    debuggerModel() {
+        return this.#runtimeModel.debuggerModel();
+    }
+    runtimeModel() {
+        return this.#runtimeModel;
+    }
+    async enable() {
+        if (this.#enabled) {
+            return;
+        }
+        this.#enabled = true;
+        await this.#heapProfilerAgent.invoke_enable();
+    }
+    async startSampling(samplingRateInBytes) {
+        if (this.#samplingProfilerDepth++) {
+            return false;
+        }
+        const defaultSamplingIntervalInBytes = 16384;
+        const response = await this.#heapProfilerAgent.invoke_startSampling({ samplingInterval: samplingRateInBytes || defaultSamplingIntervalInBytes });
+        return Boolean(response.getError());
+    }
+    async stopSampling() {
+        if (!this.#samplingProfilerDepth) {
+            throw new Error('Sampling profiler is not running.');
+        }
+        if (--this.#samplingProfilerDepth) {
+            return await this.getSamplingProfile();
+        }
+        const response = await this.#heapProfilerAgent.invoke_stopSampling();
+        if (response.getError()) {
+            return null;
+        }
+        return response.profile;
+    }
+    async getSamplingProfile() {
+        const response = await this.#heapProfilerAgent.invoke_getSamplingProfile();
+        if (response.getError()) {
+            return null;
+        }
+        return response.profile;
+    }
+    async collectGarbage() {
+        const response = await this.#heapProfilerAgent.invoke_collectGarbage();
+        return Boolean(response.getError());
+    }
+    async snapshotObjectIdForObjectId(objectId) {
+        const response = await this.#heapProfilerAgent.invoke_getHeapObjectId({ objectId });
+        if (response.getError()) {
+            return null;
+        }
+        return response.heapSnapshotObjectId;
+    }
+    async objectForSnapshotObjectId(snapshotObjectId, objectGroupName) {
+        const result = await this.#heapProfilerAgent.invoke_getObjectByHeapObjectId({ objectId: snapshotObjectId, objectGroup: objectGroupName });
+        if (result.getError()) {
+            return null;
+        }
+        return this.#runtimeModel.createRemoteObject(result.result);
+    }
+    async addInspectedHeapObject(snapshotObjectId) {
+        const response = await this.#heapProfilerAgent.invoke_addInspectedHeapObject({ heapObjectId: snapshotObjectId });
+        return Boolean(response.getError());
+    }
+    async takeHeapSnapshot(heapSnapshotOptions) {
+        await this.#heapProfilerAgent.invoke_takeHeapSnapshot(heapSnapshotOptions);
+    }
+    async startTrackingHeapObjects(recordAllocationStacks) {
+        const response = await this.#heapProfilerAgent.invoke_startTrackingHeapObjects({ trackAllocations: recordAllocationStacks });
+        return Boolean(response.getError());
+    }
+    async stopTrackingHeapObjects(reportProgress) {
+        const response = await this.#heapProfilerAgent.invoke_stopTrackingHeapObjects({ reportProgress });
+        return Boolean(response.getError());
+    }
+    heapStatsUpdate(samples) {
+        this.dispatchEventToListeners("HeapStatsUpdate" /* Events.HEAP_STATS_UPDATED */, samples);
+    }
+    lastSeenObjectId(lastSeenObjectId, timestamp) {
+        this.dispatchEventToListeners("LastSeenObjectId" /* Events.LAST_SEEN_OBJECT_ID */, { lastSeenObjectId, timestamp });
+    }
+    addHeapSnapshotChunk(chunk) {
+        this.dispatchEventToListeners("AddHeapSnapshotChunk" /* Events.ADD_HEAP_SNAPSHOT_CHUNK */, chunk);
+    }
+    reportHeapSnapshotProgress(done, total, finished) {
+        this.dispatchEventToListeners("ReportHeapSnapshotProgress" /* Events.REPORT_HEAP_SNAPSHOT_PROGRESS */, { done, total, finished });
+    }
+    resetProfiles() {
+        this.dispatchEventToListeners("ResetProfiles" /* Events.RESET_PROFILES */, this);
+    }
+}
+class HeapProfilerDispatcher {
+    #heapProfilerModel;
+    constructor(model) {
+        this.#heapProfilerModel = model;
+    }
+    heapStatsUpdate({ statsUpdate }) {
+        this.#heapProfilerModel.heapStatsUpdate(statsUpdate);
+    }
+    lastSeenObjectId({ lastSeenObjectId, timestamp }) {
+        this.#heapProfilerModel.lastSeenObjectId(lastSeenObjectId, timestamp);
+    }
+    addHeapSnapshotChunk({ chunk }) {
+        this.#heapProfilerModel.addHeapSnapshotChunk(chunk);
+    }
+    reportHeapSnapshotProgress({ done, total, finished }) {
+        this.#heapProfilerModel.reportHeapSnapshotProgress(done, total, finished);
+    }
+    resetProfiles() {
+        this.#heapProfilerModel.resetProfiles();
+    }
+}
+SDKModel.register(HeapProfilerModel, { capabilities: 4 /* Capability.JS */, autostart: false });

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

@@ -0,0 +1,73 @@
+// Copyright 2023 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 '../i18n/i18n.js';
+// Reason phrase sources
+// See https://www.rfc-editor.org/rfc/rfc9110.html#name-status-codes
+export function getStatusText(statusCode) {
+    const statusTextLookup = {
+        100: 'Continue',
+        101: 'Switching Protocols',
+        102: 'Processing',
+        103: 'Early Hints',
+        200: 'OK',
+        201: 'Created',
+        202: 'Accepted',
+        203: 'Non-Authoritative Information',
+        204: 'No Content',
+        205: 'Reset Content',
+        206: 'Partial Content',
+        207: 'Multi-Status',
+        208: 'Already Reported',
+        226: 'IM Used',
+        300: 'Multiple Choices',
+        301: 'Moved Permanently',
+        302: 'Found',
+        303: 'See Other',
+        304: 'Not Modified',
+        305: 'Use Proxy',
+        307: 'Temporary Redirect',
+        308: 'Permanent Redirect',
+        400: 'Bad Request',
+        401: 'Unauthorized',
+        402: 'Payment Required',
+        403: 'Forbidden',
+        404: 'Not Found',
+        405: 'Method Not Allowed',
+        406: 'Not Acceptable',
+        407: 'Proxy Authentication Required',
+        408: 'Request Timeout',
+        409: 'Conflict',
+        410: 'Gone',
+        411: 'Length Required',
+        412: 'Precondition Failed',
+        413: 'Content Too Large',
+        414: 'URI Too Long',
+        415: 'Unsupported Media Type',
+        416: 'Range Not Satisfiable',
+        417: 'Expectation Failed',
+        418: 'I\'m a teapot',
+        421: 'Misdirected Request',
+        422: 'Unprocessable Content',
+        423: 'Locked',
+        424: 'Failed Dependency',
+        425: 'Too Early',
+        426: 'Upgrade Required',
+        428: 'Precondition Required',
+        429: 'Too Many Requests',
+        431: 'Request Header Fields Too Large',
+        451: 'Unavailable For Legal Reasons',
+        500: 'Internal Server Error',
+        501: 'Not Implemented',
+        502: 'Bad Gateway',
+        503: 'Service Unavailable',
+        504: 'Gateway Timeout',
+        505: 'HTTP Version Not Supported',
+        506: 'Variant Also Negotiates',
+        507: 'Insufficient Storage',
+        508: 'Loop Detected',
+        510: 'Not Extended',
+        511: 'Network Authentication Required',
+    };
+    return i18n.i18n.lockedString(statusTextLookup[statusCode] ?? '');
+}

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

@@ -0,0 +1,83 @@
+// 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 { RemoteObject } from './RemoteObject.js';
+import { SDKModel } from './SDKModel.js';
+export class IOModel extends SDKModel {
+    async read(handle, size, offset) {
+        const result = await this.target().ioAgent().invoke_read({ handle, offset, size });
+        if (result.getError()) {
+            throw new Error(result.getError());
+        }
+        if (result.eof) {
+            return null;
+        }
+        if (result.base64Encoded) {
+            return Common.Base64.decode(result.data);
+        }
+        return result.data;
+    }
+    async close(handle) {
+        const result = await this.target().ioAgent().invoke_close({ handle });
+        if (result.getError()) {
+            console.error('Could not close stream.');
+        }
+    }
+    async resolveBlob(objectOrObjectId) {
+        const objectId = objectOrObjectId instanceof RemoteObject ? objectOrObjectId.objectId : objectOrObjectId;
+        if (!objectId) {
+            throw new Error('Remote object has undefined objectId');
+        }
+        const result = await this.target().ioAgent().invoke_resolveBlob({ objectId });
+        if (result.getError()) {
+            throw new Error(result.getError());
+        }
+        return `blob:${result.uuid}`;
+    }
+    async readToString(handle) {
+        const strings = [];
+        const decoder = new TextDecoder();
+        for (;;) {
+            const data = await this.read(handle, 1024 * 1024);
+            if (data === null) {
+                strings.push(decoder.decode());
+                break;
+            }
+            if (data instanceof Uint8Array) {
+                strings.push(decoder.decode(data, { stream: true }));
+            }
+            else {
+                strings.push(data);
+            }
+        }
+        return strings.join('');
+    }
+    async readToBuffer(handle) {
+        const items = [];
+        for (;;) {
+            const data = await this.read(handle, 1024 * 1024);
+            if (data === null) {
+                break;
+            }
+            if (data instanceof Uint8Array) {
+                items.push(data);
+            }
+            else {
+                throw new Error('Unexpected stream data type: expected binary, got a string');
+            }
+        }
+        let length = 0;
+        for (const item of items) {
+            length += item.length;
+        }
+        const result = new Uint8Array(length);
+        let offset = 0;
+        for (const item of items) {
+            result.set(item, offset);
+            offset += item.length;
+        }
+        return result;
+    }
+}
+SDKModel.register(IOModel, { capabilities: 131072 /* Capability.IO */, autostart: true });

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

@@ -0,0 +1,208 @@
+// 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 Common from '../common/common.js';
+import { RuntimeModel } from './RuntimeModel.js';
+import { TargetManager } from './TargetManager.js';
+let isolateManagerInstance;
+export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper {
+    #isolates = new Map();
+    /**
+     * Contains null while the isolateId is being retrieved.
+     */
+    #isolateIdByModel = new Map();
+    #observers = new Set();
+    #pollId = 0;
+    constructor() {
+        super();
+        TargetManager.instance().observeModels(RuntimeModel, this);
+    }
+    static instance({ forceNew } = { forceNew: false }) {
+        if (!isolateManagerInstance || forceNew) {
+            isolateManagerInstance = new IsolateManager();
+        }
+        return isolateManagerInstance;
+    }
+    observeIsolates(observer) {
+        if (this.#observers.has(observer)) {
+            throw new Error('Observer can only be registered once');
+        }
+        if (!this.#observers.size) {
+            void this.poll();
+        }
+        this.#observers.add(observer);
+        for (const isolate of this.#isolates.values()) {
+            observer.isolateAdded(isolate);
+        }
+    }
+    modelAdded(model) {
+        void this.#modelAdded(model);
+    }
+    async #modelAdded(model) {
+        this.#isolateIdByModel.set(model, null);
+        const isolateId = await model.isolateId();
+        if (!this.#isolateIdByModel.has(model)) {
+            // The model has been removed during await.
+            return;
+        }
+        if (!isolateId) {
+            this.#isolateIdByModel.delete(model);
+            return;
+        }
+        this.#isolateIdByModel.set(model, isolateId);
+        let isolate = this.#isolates.get(isolateId);
+        if (!isolate) {
+            isolate = new Isolate(isolateId);
+            this.#isolates.set(isolateId, isolate);
+        }
+        isolate.models().add(model);
+        if (isolate.models().size === 1) {
+            for (const observer of this.#observers) {
+                observer.isolateAdded(isolate);
+            }
+        }
+        else {
+            for (const observer of this.#observers) {
+                observer.isolateChanged(isolate);
+            }
+        }
+    }
+    modelRemoved(model) {
+        const isolateId = this.#isolateIdByModel.get(model);
+        this.#isolateIdByModel.delete(model);
+        if (!isolateId) {
+            return;
+        }
+        const isolate = this.#isolates.get(isolateId);
+        if (!isolate) {
+            return;
+        }
+        isolate.models().delete(model);
+        if (isolate.models().size) {
+            for (const observer of this.#observers) {
+                observer.isolateChanged(isolate);
+            }
+            return;
+        }
+        for (const observer of this.#observers) {
+            observer.isolateRemoved(isolate);
+        }
+        this.#isolates.delete(isolateId);
+    }
+    isolateByModel(model) {
+        return this.#isolates.get(this.#isolateIdByModel.get(model) || '') || null;
+    }
+    isolates() {
+        return this.#isolates.values();
+    }
+    async poll() {
+        const pollId = this.#pollId;
+        while (pollId === this.#pollId) {
+            await Promise.all(Array.from(this.isolates(), isolate => isolate.update()));
+            await new Promise(r => window.setTimeout(r, PollIntervalMs));
+        }
+    }
+}
+export const MemoryTrendWindowMs = 120e3;
+const PollIntervalMs = 2e3;
+export class Isolate {
+    #id;
+    #models;
+    #usedHeapSize;
+    #memoryTrend;
+    constructor(id) {
+        this.#id = id;
+        this.#models = new Set();
+        this.#usedHeapSize = 0;
+        const count = MemoryTrendWindowMs / PollIntervalMs;
+        this.#memoryTrend = new MemoryTrend(count);
+    }
+    id() {
+        return this.#id;
+    }
+    models() {
+        return this.#models;
+    }
+    runtimeModel() {
+        return this.#models.values().next().value || null;
+    }
+    heapProfilerModel() {
+        const runtimeModel = this.runtimeModel();
+        return runtimeModel?.heapProfilerModel() ?? null;
+    }
+    async update() {
+        const model = this.runtimeModel();
+        const usage = model && await model.heapUsage();
+        if (!usage) {
+            return;
+        }
+        this.#usedHeapSize = usage.usedSize + (usage.embedderHeapUsedSize ?? 0) + (usage.backingStorageSize ?? 0);
+        this.#memoryTrend.add(this.#usedHeapSize);
+        IsolateManager.instance().dispatchEventToListeners("MemoryChanged" /* Events.MEMORY_CHANGED */, this);
+    }
+    samplesCount() {
+        return this.#memoryTrend.count();
+    }
+    usedHeapSize() {
+        return this.#usedHeapSize;
+    }
+    /**
+     * bytes per millisecond
+     */
+    usedHeapSizeGrowRate() {
+        return this.#memoryTrend.fitSlope();
+    }
+}
+export class MemoryTrend {
+    #maxCount;
+    #base;
+    #index;
+    #x;
+    #y;
+    #sx;
+    #sy;
+    #sxx;
+    #sxy;
+    constructor(maxCount) {
+        this.#maxCount = maxCount | 0;
+        this.reset();
+    }
+    reset() {
+        this.#base = Date.now();
+        this.#index = 0;
+        this.#x = [];
+        this.#y = [];
+        this.#sx = 0;
+        this.#sy = 0;
+        this.#sxx = 0;
+        this.#sxy = 0;
+    }
+    count() {
+        return this.#x.length;
+    }
+    add(heapSize, timestamp) {
+        const x = typeof timestamp === 'number' ? timestamp : Date.now() - this.#base;
+        const y = heapSize;
+        if (this.#x.length === this.#maxCount) {
+            // Turns into a cyclic buffer once it reaches the |#maxCount|.
+            const x0 = this.#x[this.#index];
+            const y0 = this.#y[this.#index];
+            this.#sx -= x0;
+            this.#sy -= y0;
+            this.#sxx -= x0 * x0;
+            this.#sxy -= x0 * y0;
+        }
+        this.#sx += x;
+        this.#sy += y;
+        this.#sxx += x * x;
+        this.#sxy += x * y;
+        this.#x[this.#index] = x;
+        this.#y[this.#index] = y;
+        this.#index = (this.#index + 1) % this.#maxCount;
+    }
+    fitSlope() {
+        // We use the linear regression model to find the slope.
+        const n = this.count();
+        return n < 2 ? 0 : (this.#sxy - this.#sx * this.#sy / n) / (this.#sxx - this.#sx * this.#sx / n);
+    }
+}

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

@@ -0,0 +1,41 @@
+// 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 { SDKModel } from './SDKModel.js';
+/**
+ * The `IssuesModel` is a thin dispatch that does not store issues, but only creates the representation
+ * class (usually derived from `Issue`) and passes the instances on via a dispatched event.
+ * We chose this approach here because the lifetime of the Model is tied to the target, but DevTools
+ * wants to preserve issues for targets (e.g. iframes) that are already gone as well.
+ */
+export class IssuesModel extends SDKModel {
+    #disposed = false;
+    #enabled = false;
+    constructor(target) {
+        super(target);
+        void this.ensureEnabled();
+    }
+    async ensureEnabled() {
+        if (this.#enabled) {
+            return;
+        }
+        this.#enabled = true;
+        this.target().registerAuditsDispatcher(this);
+        const auditsAgent = this.target().auditsAgent();
+        await auditsAgent.invoke_enable();
+    }
+    issueAdded(issueAddedEvent) {
+        this.dispatchEventToListeners("IssueAdded" /* Events.ISSUE_ADDED */, { issuesModel: this, inspectorIssue: issueAddedEvent.issue });
+    }
+    dispose() {
+        super.dispose();
+        this.#disposed = true;
+    }
+    getTargetIfNotDisposed() {
+        if (!this.#disposed) {
+            return this.target();
+        }
+        return null;
+    }
+}
+SDKModel.register(IssuesModel, { capabilities: 32768 /* Capability.AUDITS */, autostart: true });

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

@@ -0,0 +1,95 @@
+// Copyright 2016 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { DOMModel } from './DOMModel.js';
+export class StickyPositionConstraint {
+    #stickyBoxRect;
+    #containingBlockRect;
+    #nearestLayerShiftingStickyBox;
+    #nearestLayerShiftingContainingBlock;
+    constructor(layerTree, constraint) {
+        this.#stickyBoxRect = constraint.stickyBoxRect;
+        this.#containingBlockRect = constraint.containingBlockRect;
+        this.#nearestLayerShiftingStickyBox = null;
+        if (layerTree && constraint.nearestLayerShiftingStickyBox) {
+            this.#nearestLayerShiftingStickyBox = layerTree.layerById(constraint.nearestLayerShiftingStickyBox);
+        }
+        this.#nearestLayerShiftingContainingBlock = null;
+        if (layerTree && constraint.nearestLayerShiftingContainingBlock) {
+            this.#nearestLayerShiftingContainingBlock = layerTree.layerById(constraint.nearestLayerShiftingContainingBlock);
+        }
+    }
+    stickyBoxRect() {
+        return this.#stickyBoxRect;
+    }
+    containingBlockRect() {
+        return this.#containingBlockRect;
+    }
+    nearestLayerShiftingStickyBox() {
+        return this.#nearestLayerShiftingStickyBox;
+    }
+    nearestLayerShiftingContainingBlock() {
+        return this.#nearestLayerShiftingContainingBlock;
+    }
+}
+export class LayerTreeBase {
+    #target;
+    #domModel;
+    layersById = new Map();
+    #root = null;
+    #contentRoot = null;
+    #backendNodeIdToNode = new Map();
+    #viewportSize;
+    constructor(target) {
+        this.#target = target;
+        this.#domModel = target ? target.model(DOMModel) : null;
+    }
+    target() {
+        return this.#target;
+    }
+    root() {
+        return this.#root;
+    }
+    setRoot(root) {
+        this.#root = root;
+    }
+    contentRoot() {
+        return this.#contentRoot;
+    }
+    setContentRoot(contentRoot) {
+        this.#contentRoot = contentRoot;
+    }
+    forEachLayer(callback, root) {
+        if (!root) {
+            root = this.root();
+            if (!root) {
+                return false;
+            }
+        }
+        return callback(root) || root.children().some(this.forEachLayer.bind(this, callback));
+    }
+    layerById(id) {
+        return this.layersById.get(id) || null;
+    }
+    async resolveBackendNodeIds(requestedNodeIds) {
+        if (!requestedNodeIds.size || !this.#domModel) {
+            return;
+        }
+        const nodesMap = await this.#domModel.pushNodesByBackendIdsToFrontend(requestedNodeIds);
+        if (!nodesMap) {
+            return;
+        }
+        for (const nodeId of nodesMap.keys()) {
+            this.#backendNodeIdToNode.set(nodeId, nodesMap.get(nodeId) || null);
+        }
+    }
+    backendNodeIdToNode() {
+        return this.#backendNodeIdToNode;
+    }
+    setViewportSize(viewportSize) {
+        this.#viewportSize = viewportSize;
+    }
+    viewportSize() {
+        return this.#viewportSize;
+    }
+}

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

@@ -0,0 +1,34 @@
+// 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 Host from '../host/host.js';
+import { SDKModel } from './SDKModel.js';
+export class LogModel extends SDKModel {
+    #logAgent;
+    constructor(target) {
+        super(target);
+        target.registerLogDispatcher(this);
+        this.#logAgent = target.logAgent();
+        void this.#logAgent.invoke_enable();
+        if (!Host.InspectorFrontendHost.isUnderTest()) {
+            void this.#logAgent.invoke_startViolationsReport({
+                config: [
+                    { name: "longTask" /* Protocol.Log.ViolationSettingName.LongTask */, threshold: 200 },
+                    { name: "longLayout" /* Protocol.Log.ViolationSettingName.LongLayout */, threshold: 30 },
+                    { name: "blockedEvent" /* Protocol.Log.ViolationSettingName.BlockedEvent */, threshold: 100 },
+                    { name: "blockedParser" /* Protocol.Log.ViolationSettingName.BlockedParser */, threshold: -1 },
+                    { name: "handler" /* Protocol.Log.ViolationSettingName.Handler */, threshold: 150 },
+                    { name: "recurringHandler" /* Protocol.Log.ViolationSettingName.RecurringHandler */, threshold: 50 },
+                    { name: "discouragedAPIUse" /* Protocol.Log.ViolationSettingName.DiscouragedAPIUse */, threshold: -1 },
+                ],
+            });
+        }
+    }
+    entryAdded({ entry }) {
+        this.dispatchEventToListeners("EntryAdded" /* Events.ENTRY_ADDED */, { logModel: this, entry });
+    }
+    requestClear() {
+        void this.#logAgent.invoke_clear();
+    }
+}
+SDKModel.register(LogModel, { capabilities: 8 /* Capability.LOG */, autostart: true });