chrome-devtools-mcp 0.0.2 → 0.2.0

package/build/node_modules/chrome-devtools-frontend/front_end/models/bindings/FileUtils.js

@@ -0,0 +1,186 @@
+// Copyright 2012 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 '../../core/common/common.js';
+import * as TextUtils from '../text_utils/text_utils.js';
+import * as Workspace from '../workspace/workspace.js';
+export class ChunkedFileReader {
+    #file;
+    #fileSize;
+    #loadedSize;
+    #streamReader;
+    #chunkSize;
+    #chunkTransferredCallback;
+    #decoder;
+    #isCanceled;
+    #error;
+    #transferFinished;
+    #output;
+    #reader;
+    constructor(file, chunkSize, chunkTransferredCallback) {
+        this.#file = file;
+        this.#fileSize = file.size;
+        this.#loadedSize = 0;
+        this.#chunkSize = (chunkSize) ? chunkSize : Number.MAX_VALUE;
+        this.#chunkTransferredCallback = chunkTransferredCallback;
+        this.#decoder = new TextDecoder();
+        this.#isCanceled = false;
+        this.#error = null;
+        this.#streamReader = null;
+    }
+    async read(output) {
+        if (this.#chunkTransferredCallback) {
+            this.#chunkTransferredCallback(this);
+        }
+        if (this.#file?.type.endsWith('gzip')) {
+            const fileStream = this.#file.stream();
+            const stream = Common.Gzip.decompressStream(fileStream);
+            this.#streamReader = stream.getReader();
+        }
+        else {
+            this.#reader = new FileReader();
+            this.#reader.onload = this.onChunkLoaded.bind(this);
+            this.#reader.onerror = this.onError.bind(this);
+        }
+        this.#output = output;
+        void this.loadChunk();
+        return await new Promise(resolve => {
+            this.#transferFinished = resolve;
+        });
+    }
+    cancel() {
+        this.#isCanceled = true;
+    }
+    loadedSize() {
+        return this.#loadedSize;
+    }
+    fileSize() {
+        return this.#fileSize;
+    }
+    fileName() {
+        if (!this.#file) {
+            return '';
+        }
+        return this.#file.name;
+    }
+    error() {
+        return this.#error;
+    }
+    onChunkLoaded(event) {
+        if (this.#isCanceled) {
+            return;
+        }
+        const eventTarget = event.target;
+        if (eventTarget.readyState !== FileReader.DONE) {
+            return;
+        }
+        if (!this.#reader) {
+            return;
+        }
+        const buffer = this.#reader.result;
+        this.#loadedSize += buffer.byteLength;
+        const endOfFile = this.#loadedSize === this.#fileSize;
+        void this.decodeChunkBuffer(buffer, endOfFile);
+    }
+    async decodeChunkBuffer(buffer, endOfFile) {
+        if (!this.#output) {
+            return;
+        }
+        const decodedString = this.#decoder.decode(buffer, { stream: !endOfFile });
+        await this.#output.write(decodedString, endOfFile);
+        if (this.#isCanceled) {
+            return;
+        }
+        if (this.#chunkTransferredCallback) {
+            this.#chunkTransferredCallback(this);
+        }
+        if (endOfFile) {
+            void this.finishRead();
+            return;
+        }
+        void this.loadChunk();
+    }
+    async finishRead() {
+        if (!this.#output) {
+            return;
+        }
+        this.#file = null;
+        this.#reader = null;
+        await this.#output.close();
+        this.#transferFinished(!this.#error);
+    }
+    async loadChunk() {
+        if (!this.#output || !this.#file) {
+            return;
+        }
+        if (this.#streamReader) {
+            const { value, done } = await this.#streamReader.read();
+            if (done || !value) {
+                // Write empty string to inform of file end
+                await this.#output.write('', true);
+                return await this.finishRead();
+            }
+            void this.decodeChunkBuffer(value.buffer, false);
+        }
+        if (this.#reader) {
+            const chunkStart = this.#loadedSize;
+            const chunkEnd = Math.min(this.#fileSize, chunkStart + this.#chunkSize);
+            const nextPart = this.#file.slice(chunkStart, chunkEnd);
+            this.#reader.readAsArrayBuffer(nextPart);
+        }
+    }
+    onError(event) {
+        const eventTarget = event.target;
+        this.#error = eventTarget.error;
+        this.#transferFinished(false);
+    }
+}
+export class FileOutputStream {
+    #writeCallbacks;
+    #fileName;
+    #closed;
+    constructor() {
+        this.#writeCallbacks = [];
+    }
+    async open(fileName) {
+        this.#closed = false;
+        this.#writeCallbacks = [];
+        this.#fileName = fileName;
+        const saveResponse = await Workspace.FileManager.FileManager.instance().save(this.#fileName, TextUtils.ContentData.EMPTY_TEXT_CONTENT_DATA, /* forceSaveAs=*/ true);
+        if (saveResponse) {
+            Workspace.FileManager.FileManager.instance().addEventListener("AppendedToURL" /* Workspace.FileManager.Events.APPENDED_TO_URL */, this.onAppendDone, this);
+        }
+        return Boolean(saveResponse);
+    }
+    write(data) {
+        return new Promise(resolve => {
+            this.#writeCallbacks.push(resolve);
+            Workspace.FileManager.FileManager.instance().append(this.#fileName, data);
+        });
+    }
+    async close() {
+        this.#closed = true;
+        if (this.#writeCallbacks.length) {
+            return;
+        }
+        Workspace.FileManager.FileManager.instance().removeEventListener("AppendedToURL" /* Workspace.FileManager.Events.APPENDED_TO_URL */, this.onAppendDone, this);
+        Workspace.FileManager.FileManager.instance().close(this.#fileName);
+    }
+    onAppendDone(event) {
+        if (event.data !== this.#fileName) {
+            return;
+        }
+        const writeCallback = this.#writeCallbacks.shift();
+        if (writeCallback) {
+            writeCallback();
+        }
+        if (this.#writeCallbacks.length) {
+            return;
+        }
+        if (!this.#closed) {
+            return;
+        }
+        Workspace.FileManager.FileManager.instance().removeEventListener("AppendedToURL" /* Workspace.FileManager.Events.APPENDED_TO_URL */, this.onAppendDone, this);
+        Workspace.FileManager.FileManager.instance().close(this.#fileName);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/bindings/LiveLocation.js

@@ -0,0 +1,60 @@
+// Copyright 2014 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export class LiveLocationWithPool {
+    #updateDelegate;
+    #locationPool;
+    #updatePromise;
+    constructor(updateDelegate, locationPool) {
+        this.#updateDelegate = updateDelegate;
+        this.#locationPool = locationPool;
+        this.#locationPool.add(this);
+        this.#updatePromise = null;
+    }
+    async update() {
+        if (!this.#updateDelegate) {
+            return;
+        }
+        // The following is a basic scheduling algorithm, guaranteeing that
+        // {#updateDelegate} is always run atomically. That is, we always
+        // wait for an update to finish before we trigger the next run.
+        if (this.#updatePromise) {
+            await this.#updatePromise.then(() => this.update());
+        }
+        else {
+            this.#updatePromise = this.#updateDelegate(this);
+            await this.#updatePromise;
+            this.#updatePromise = null;
+        }
+    }
+    async uiLocation() {
+        throw new Error('Not implemented');
+    }
+    dispose() {
+        this.#locationPool.delete(this);
+        this.#updateDelegate = null;
+    }
+    isDisposed() {
+        return !this.#locationPool.has(this);
+    }
+}
+export class LiveLocationPool {
+    #locations;
+    constructor() {
+        this.#locations = new Set();
+    }
+    add(location) {
+        this.#locations.add(location);
+    }
+    delete(location) {
+        this.#locations.delete(location);
+    }
+    has(location) {
+        return this.#locations.has(location);
+    }
+    disposeAll() {
+        for (const location of this.#locations) {
+            location.dispose();
+        }
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/bindings/NetworkProject.js

@@ -0,0 +1,107 @@
+// Copyright 2012 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 '../../core/common/common.js';
+import * as SDK from '../../core/sdk/sdk.js';
+const uiSourceCodeToAttributionMap = new WeakMap();
+const projectToTargetMap = new WeakMap();
+let networkProjectManagerInstance;
+export class NetworkProjectManager extends Common.ObjectWrapper.ObjectWrapper {
+    constructor() {
+        super();
+    }
+    static instance({ forceNew } = { forceNew: false }) {
+        if (!networkProjectManagerInstance || forceNew) {
+            networkProjectManagerInstance = new NetworkProjectManager();
+        }
+        return networkProjectManagerInstance;
+    }
+}
+export class NetworkProject {
+    static resolveFrame(uiSourceCode, frameId) {
+        const target = NetworkProject.targetForUISourceCode(uiSourceCode);
+        const resourceTreeModel = target?.model(SDK.ResourceTreeModel.ResourceTreeModel);
+        return resourceTreeModel ? resourceTreeModel.frameForId(frameId) : null;
+    }
+    static setInitialFrameAttribution(uiSourceCode, frameId) {
+        if (!frameId) {
+            return;
+        }
+        const frame = NetworkProject.resolveFrame(uiSourceCode, frameId);
+        if (!frame) {
+            return;
+        }
+        const attribution = new Map();
+        attribution.set(frameId, { frame, count: 1 });
+        uiSourceCodeToAttributionMap.set(uiSourceCode, attribution);
+    }
+    static cloneInitialFrameAttribution(fromUISourceCode, toUISourceCode) {
+        const fromAttribution = uiSourceCodeToAttributionMap.get(fromUISourceCode);
+        if (!fromAttribution) {
+            return;
+        }
+        const toAttribution = new Map();
+        for (const frameId of fromAttribution.keys()) {
+            const value = fromAttribution.get(frameId);
+            if (typeof value !== 'undefined') {
+                toAttribution.set(frameId, { frame: value.frame, count: value.count });
+            }
+        }
+        uiSourceCodeToAttributionMap.set(toUISourceCode, toAttribution);
+    }
+    static addFrameAttribution(uiSourceCode, frameId) {
+        const frame = NetworkProject.resolveFrame(uiSourceCode, frameId);
+        if (!frame) {
+            return;
+        }
+        const frameAttribution = uiSourceCodeToAttributionMap.get(uiSourceCode);
+        if (!frameAttribution) {
+            return;
+        }
+        const attributionInfo = frameAttribution.get(frameId) || { frame, count: 0 };
+        attributionInfo.count += 1;
+        frameAttribution.set(frameId, attributionInfo);
+        if (attributionInfo.count !== 1) {
+            return;
+        }
+        const data = { uiSourceCode, frame };
+        NetworkProjectManager.instance().dispatchEventToListeners("FrameAttributionAdded" /* Events.FRAME_ATTRIBUTION_ADDED */, data);
+    }
+    static removeFrameAttribution(uiSourceCode, frameId) {
+        const frameAttribution = uiSourceCodeToAttributionMap.get(uiSourceCode);
+        if (!frameAttribution) {
+            return;
+        }
+        const attributionInfo = frameAttribution.get(frameId);
+        console.assert(Boolean(attributionInfo), 'Failed to remove frame attribution for url: ' + uiSourceCode.url());
+        if (!attributionInfo) {
+            return;
+        }
+        attributionInfo.count -= 1;
+        if (attributionInfo.count > 0) {
+            return;
+        }
+        frameAttribution.delete(frameId);
+        const data = { uiSourceCode, frame: attributionInfo.frame };
+        NetworkProjectManager.instance().dispatchEventToListeners("FrameAttributionRemoved" /* Events.FRAME_ATTRIBUTION_REMOVED */, data);
+    }
+    static targetForUISourceCode(uiSourceCode) {
+        return projectToTargetMap.get(uiSourceCode.project()) || null;
+    }
+    static setTargetForProject(project, target) {
+        projectToTargetMap.set(project, target);
+    }
+    static getTargetForProject(project) {
+        return projectToTargetMap.get(project) || null;
+    }
+    static framesForUISourceCode(uiSourceCode) {
+        const target = NetworkProject.targetForUISourceCode(uiSourceCode);
+        const resourceTreeModel = target?.model(SDK.ResourceTreeModel.ResourceTreeModel);
+        const attribution = uiSourceCodeToAttributionMap.get(uiSourceCode);
+        if (!resourceTreeModel || !attribution) {
+            return [];
+        }
+        const frames = Array.from(attribution.keys()).map(frameId => resourceTreeModel.frameForId(frameId));
+        return frames.filter(frame => !!frame);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/bindings/PresentationConsoleMessageHelper.js

@@ -0,0 +1,244 @@
+// Copyright 2012 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 SDK from '../../core/sdk/sdk.js';
+import * as TextUtils from '../text_utils/text_utils.js';
+import * as Workspace from '../workspace/workspace.js';
+import { CSSWorkspaceBinding } from './CSSWorkspaceBinding.js';
+import { DebuggerWorkspaceBinding } from './DebuggerWorkspaceBinding.js';
+import { LiveLocationPool, LiveLocationWithPool } from './LiveLocation.js';
+export class PresentationSourceFrameMessageManager {
+    #targetToMessageHelperMap = new WeakMap();
+    constructor() {
+        SDK.TargetManager.TargetManager.instance().observeModels(SDK.DebuggerModel.DebuggerModel, this);
+        SDK.TargetManager.TargetManager.instance().observeModels(SDK.CSSModel.CSSModel, this);
+    }
+    modelAdded(model) {
+        const target = model.target();
+        const helper = this.#targetToMessageHelperMap.get(target) ?? new PresentationSourceFrameMessageHelper();
+        if (model instanceof SDK.DebuggerModel.DebuggerModel) {
+            helper.setDebuggerModel(model);
+        }
+        else {
+            helper.setCSSModel(model);
+        }
+        this.#targetToMessageHelperMap.set(target, helper);
+    }
+    modelRemoved(model) {
+        const target = model.target();
+        const helper = this.#targetToMessageHelperMap.get(target);
+        helper?.clear();
+    }
+    addMessage(message, source, target) {
+        const helper = this.#targetToMessageHelperMap.get(target);
+        void helper?.addMessage(message, source);
+    }
+    clear() {
+        for (const target of SDK.TargetManager.TargetManager.instance().targets()) {
+            const helper = this.#targetToMessageHelperMap.get(target);
+            helper?.clear();
+        }
+    }
+}
+export class PresentationConsoleMessageManager {
+    #sourceFrameMessageManager = new PresentationSourceFrameMessageManager();
+    constructor() {
+        SDK.TargetManager.TargetManager.instance().addModelListener(SDK.ConsoleModel.ConsoleModel, SDK.ConsoleModel.Events.MessageAdded, event => this.consoleMessageAdded(event.data));
+        SDK.ConsoleModel.ConsoleModel.allMessagesUnordered().forEach(this.consoleMessageAdded, this);
+        SDK.TargetManager.TargetManager.instance().addModelListener(SDK.ConsoleModel.ConsoleModel, SDK.ConsoleModel.Events.ConsoleCleared, () => this.#sourceFrameMessageManager.clear());
+    }
+    consoleMessageAdded(consoleMessage) {
+        const runtimeModel = consoleMessage.runtimeModel();
+        if (!consoleMessage.isErrorOrWarning() || !consoleMessage.runtimeModel() ||
+            consoleMessage.source === "violation" /* Protocol.Log.LogEntrySource.Violation */ || !runtimeModel) {
+            return;
+        }
+        const level = consoleMessage.level === "error" /* Protocol.Log.LogEntryLevel.Error */ ?
+            "Error" /* Workspace.UISourceCode.Message.Level.ERROR */ :
+            "Warning" /* Workspace.UISourceCode.Message.Level.WARNING */;
+        this.#sourceFrameMessageManager.addMessage(new Workspace.UISourceCode.Message(level, consoleMessage.messageText), consoleMessage, runtimeModel.target());
+    }
+}
+export class PresentationSourceFrameMessageHelper {
+    #debuggerModel;
+    #cssModel;
+    #presentationMessages = new Map();
+    #locationPool;
+    constructor() {
+        this.#locationPool = new LiveLocationPool();
+        Workspace.Workspace.WorkspaceImpl.instance().addEventListener(Workspace.Workspace.Events.UISourceCodeAdded, this.#uiSourceCodeAdded.bind(this));
+    }
+    setDebuggerModel(debuggerModel) {
+        if (this.#debuggerModel) {
+            throw new Error('Cannot set DebuggerModel twice');
+        }
+        this.#debuggerModel = debuggerModel;
+        // TODO(dgozman): queueMicrotask because we race with DebuggerWorkspaceBinding on ParsedScriptSource event delivery.
+        debuggerModel.addEventListener(SDK.DebuggerModel.Events.ParsedScriptSource, event => {
+            queueMicrotask(() => {
+                this.#parsedScriptSource(event);
+            });
+        });
+        debuggerModel.addEventListener(SDK.DebuggerModel.Events.GlobalObjectCleared, this.#debuggerReset, this);
+    }
+    setCSSModel(cssModel) {
+        if (this.#cssModel) {
+            throw new Error('Cannot set CSSModel twice');
+        }
+        this.#cssModel = cssModel;
+        cssModel.addEventListener(SDK.CSSModel.Events.StyleSheetAdded, event => queueMicrotask(() => this.#styleSheetAdded(event)));
+    }
+    async addMessage(message, source) {
+        const presentation = new PresentationSourceFrameMessage(message, this.#locationPool);
+        const location = this.#rawLocation(source) ?? this.#cssLocation(source) ?? this.#uiLocation(source);
+        if (location) {
+            await presentation.updateLocationSource(location);
+        }
+        if (source.url) {
+            let messages = this.#presentationMessages.get(source.url);
+            if (!messages) {
+                messages = [];
+                this.#presentationMessages.set(source.url, messages);
+            }
+            messages.push({ source, presentation });
+        }
+    }
+    #uiLocation(source) {
+        if (!source.url) {
+            return null;
+        }
+        const uiSourceCode = Workspace.Workspace.WorkspaceImpl.instance().uiSourceCodeForURL(source.url);
+        if (!uiSourceCode) {
+            return null;
+        }
+        return new Workspace.UISourceCode.UILocation(uiSourceCode, source.line, source.column);
+    }
+    #cssLocation(source) {
+        if (!this.#cssModel || !source.url) {
+            return null;
+        }
+        const locations = this.#cssModel.createRawLocationsByURL(source.url, source.line, source.column);
+        return locations[0] ?? null;
+    }
+    #rawLocation(source) {
+        if (!this.#debuggerModel) {
+            return null;
+        }
+        if (source.scriptId) {
+            return this.#debuggerModel.createRawLocationByScriptId(source.scriptId, source.line, source.column);
+        }
+        const callFrame = source.stackTrace?.callFrames ? source.stackTrace.callFrames[0] : null;
+        if (callFrame) {
+            return this.#debuggerModel.createRawLocationByScriptId(callFrame.scriptId, callFrame.lineNumber, callFrame.columnNumber);
+        }
+        if (source.url) {
+            return this.#debuggerModel.createRawLocationByURL(source.url, source.line, source.column);
+        }
+        return null;
+    }
+    #parsedScriptSource(event) {
+        const script = event.data;
+        const messages = this.#presentationMessages.get(script.sourceURL);
+        const promises = [];
+        for (const { presentation, source } of messages ?? []) {
+            const rawLocation = this.#rawLocation(source);
+            if (rawLocation && script.scriptId === rawLocation.scriptId) {
+                promises.push(presentation.updateLocationSource(rawLocation));
+            }
+        }
+        void Promise.all(promises).then(this.parsedScriptSourceForTest.bind(this));
+    }
+    parsedScriptSourceForTest() {
+    }
+    #uiSourceCodeAdded(event) {
+        const uiSourceCode = event.data;
+        const messages = this.#presentationMessages.get(uiSourceCode.url());
+        const promises = [];
+        for (const { presentation, source } of messages ?? []) {
+            promises.push(presentation.updateLocationSource(new Workspace.UISourceCode.UILocation(uiSourceCode, source.line, source.column)));
+        }
+        void Promise.all(promises).then(this.uiSourceCodeAddedForTest.bind(this));
+    }
+    uiSourceCodeAddedForTest() {
+    }
+    #styleSheetAdded(event) {
+        const header = event.data;
+        const messages = this.#presentationMessages.get(header.sourceURL);
+        const promises = [];
+        for (const { source, presentation } of messages ?? []) {
+            if (header.containsLocation(source.line, source.column)) {
+                promises.push(presentation.updateLocationSource(new SDK.CSSModel.CSSLocation(header, source.line, source.column)));
+            }
+        }
+        void Promise.all(promises).then(this.styleSheetAddedForTest.bind(this));
+    }
+    styleSheetAddedForTest() {
+    }
+    clear() {
+        this.#debuggerReset();
+    }
+    #debuggerReset() {
+        const presentations = Array.from(this.#presentationMessages.values()).flat();
+        for (const { presentation } of presentations) {
+            presentation.dispose();
+        }
+        this.#presentationMessages.clear();
+        this.#locationPool.disposeAll();
+    }
+}
+class FrozenLiveLocation extends LiveLocationWithPool {
+    #uiLocation;
+    constructor(uiLocation, updateDelegate, locationPool) {
+        super(updateDelegate, locationPool);
+        this.#uiLocation = uiLocation;
+    }
+    async uiLocation() {
+        return this.#uiLocation;
+    }
+}
+export class PresentationSourceFrameMessage {
+    #uiSourceCode;
+    #liveLocation;
+    #locationPool;
+    #message;
+    constructor(message, locationPool) {
+        this.#message = message;
+        this.#locationPool = locationPool;
+    }
+    async updateLocationSource(source) {
+        if (source instanceof SDK.DebuggerModel.Location) {
+            await DebuggerWorkspaceBinding.instance().createLiveLocation(source, this.#updateLocation.bind(this), this.#locationPool);
+        }
+        else if (source instanceof SDK.CSSModel.CSSLocation) {
+            await CSSWorkspaceBinding.instance().createLiveLocation(source, this.#updateLocation.bind(this), this.#locationPool);
+        }
+        else if (source instanceof Workspace.UISourceCode.UILocation) {
+            if (!this.#liveLocation) { // Don't "downgrade" the location if a debugger or css mapping was already successful
+                this.#liveLocation = new FrozenLiveLocation(source, this.#updateLocation.bind(this), this.#locationPool);
+                await this.#liveLocation.update();
+            }
+        }
+    }
+    async #updateLocation(liveLocation) {
+        if (this.#uiSourceCode) {
+            this.#uiSourceCode.removeMessage(this.#message);
+        }
+        if (liveLocation !== this.#liveLocation) {
+            this.#uiSourceCode?.removeMessage(this.#message);
+            this.#liveLocation?.dispose();
+            this.#liveLocation = liveLocation;
+        }
+        const uiLocation = await liveLocation.uiLocation();
+        if (!uiLocation) {
+            return;
+        }
+        this.#message.range =
+            TextUtils.TextRange.TextRange.createFromLocation(uiLocation.lineNumber, uiLocation.columnNumber || 0);
+        this.#uiSourceCode = uiLocation.uiSourceCode;
+        this.#uiSourceCode.addMessage(this.#message);
+    }
+    dispose() {
+        this.#uiSourceCode?.removeMessage(this.#message);
+        this.#liveLocation?.dispose();
+    }
+}