chrome-devtools-mcp 0.0.1 → 0.0.2

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

@@ -0,0 +1,276 @@
+// 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 { SourceMapScopeChainEntry } from './SourceMapScopeChainEntry.js';
+export class SourceMapScopesInfo {
+    #sourceMap;
+    #originalScopes;
+    #generatedRanges;
+    #cachedVariablesAndBindingsPresent = null;
+    constructor(sourceMap, scopeInfo) {
+        this.#sourceMap = sourceMap;
+        this.#originalScopes = scopeInfo.scopes;
+        this.#generatedRanges = scopeInfo.ranges;
+    }
+    addOriginalScopes(scopes) {
+        for (const scope of scopes) {
+            this.#originalScopes.push(scope);
+        }
+    }
+    addGeneratedRanges(ranges) {
+        for (const range of ranges) {
+            this.#generatedRanges.push(range);
+        }
+    }
+    hasOriginalScopes(sourceIdx) {
+        return Boolean(this.#originalScopes[sourceIdx]);
+    }
+    addOriginalScopesAtIndex(sourceIdx, scope) {
+        if (!this.#originalScopes[sourceIdx]) {
+            this.#originalScopes[sourceIdx] = scope;
+        }
+        else {
+            throw new Error(`Trying to re-augment existing scopes for source at index: ${sourceIdx}`);
+        }
+    }
+    /**
+     * Given a generated position, returns the original name of the surrounding function as well as
+     * all the original function names that got inlined into the surrounding generated function and their
+     * respective callsites in the original code (ordered from inner to outer).
+     *
+     * @returns a list with inlined functions. Every entry in the list has a callsite in the orignal code,
+     * except the last function (since the last function didn't get inlined).
+     */
+    findInlinedFunctions(generatedLine, generatedColumn) {
+        const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+        const result = {
+            inlinedFunctions: [],
+            originalFunctionName: '',
+        };
+        // Walk the generated ranges from the innermost containing range outwards as long as we don't
+        // encounter a range that is a scope in the generated code and a function scope originally.
+        for (let i = rangeChain.length - 1; i >= 0; --i) {
+            const range = rangeChain[i];
+            if (range.callSite) {
+                // Record the name and call-site if the range corresponds to an inlined function.
+                result.inlinedFunctions.push({ name: range.originalScope?.name ?? '', callsite: range.callSite });
+            }
+            if (range.isStackFrame) {
+                // We arrived at an actual generated JS function, don't go further.
+                // The corresponding original scope could not actually be a function
+                // (e.g. a block scope transpiled down to a JS function), but we'll
+                // filter that out later.
+                result.originalFunctionName = range.originalScope?.name ?? '';
+                break;
+            }
+        }
+        return result;
+    }
+    /**
+     * Takes a V8 provided call frame and expands any inlined frames into virtual call frames.
+     *
+     * For call frames where nothing was inlined, the result contains only a single element,
+     * the provided frame but with the original name.
+     *
+     * For call frames where we are paused in inlined code, this function returns a list of
+     * call frames from "inner to outer". This is the call frame at index 0
+     * signifies the top of this stack trace fragment.
+     *
+     * The rest are "virtual" call frames and will have an "inlineFrameIndex" set in ascending
+     * order, so the condition `result[index] === result[index].inlineFrameIndex` always holds.
+     */
+    expandCallFrame(callFrame) {
+        const { originalFunctionName, inlinedFunctions } = this.findInlinedFunctions(callFrame.location().lineNumber, callFrame.location().columnNumber);
+        const result = [];
+        for (const [index, fn] of inlinedFunctions.entries()) {
+            result.push(callFrame.createVirtualCallFrame(index, fn.name));
+        }
+        result.push(callFrame.createVirtualCallFrame(result.length, originalFunctionName));
+        return result;
+    }
+    /**
+     * Given a generated position, this returns all the surrounding generated ranges from outer
+     * to inner.
+     */
+    #findGeneratedRangeChain(line, column) {
+        const result = [];
+        (function walkRanges(ranges) {
+            for (const range of ranges) {
+                if (!contains(range, line, column)) {
+                    continue;
+                }
+                result.push(range);
+                walkRanges(range.children);
+            }
+        })(this.#generatedRanges);
+        return result;
+    }
+    /**
+     * @returns true if we have enough info (i.e. variable and binding expressions) to build
+     * a scope view.
+     */
+    hasVariablesAndBindings() {
+        if (this.#cachedVariablesAndBindingsPresent === null) {
+            this.#cachedVariablesAndBindingsPresent = this.#areVariablesAndBindingsPresent();
+        }
+        return this.#cachedVariablesAndBindingsPresent;
+    }
+    #areVariablesAndBindingsPresent() {
+        // We check whether any original scope has a non-empty list of variables, and
+        // generated ranges with a non-empty binding list.
+        function walkTree(nodes) {
+            for (const node of nodes) {
+                if (!node) {
+                    continue;
+                }
+                if ('variables' in node && node.variables.length > 0) {
+                    return true;
+                }
+                if ('values' in node && node.values.some(v => v !== null)) {
+                    return true;
+                }
+                if (walkTree(node.children)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return walkTree(this.#originalScopes) && walkTree(this.#generatedRanges);
+    }
+    /**
+     * Constructs a scope chain based on the CallFrame's paused position.
+     *
+     * The algorithm to obtain the original scope chain is straight-forward:
+     *
+     *   1) Find the inner-most generated range that contains the CallFrame's
+     *      paused position.
+     *
+     *   2) Does the found range have an associated original scope?
+     *
+     *      2a) If no, return null. This is a "hidden" range and technically
+     *          we shouldn't be pausing here in the first place. This code doesn't
+     *          correspond to anything in the authored code.
+     *
+     *      2b) If yes, the associated original scope is the inner-most
+     *          original scope in the resulting scope chain.
+     *
+     *   3) Walk the parent chain of the found original scope outwards. This is
+     *      our scope view. For each original scope we also try to find a
+     *      corresponding generated range that contains the CallFrame's
+     *      paused position. We need the generated range to resolve variable
+     *      values.
+     */
+    resolveMappedScopeChain(callFrame) {
+        const rangeChain = this.#findGeneratedRangeChainForFrame(callFrame);
+        const innerMostOriginalScope = rangeChain.at(-1)?.originalScope;
+        if (innerMostOriginalScope === undefined) {
+            return null;
+        }
+        // TODO(crbug.com/40277685): Add a sanity check here where we map the paused position using
+        //         the source map's mappings, find the inner-most original scope with that mapped paused
+        //         position and compare that result with `innerMostOriginalScope`. If they don't match we
+        //         should emit a warning about the broken source map as mappings and scopes are inconsistent
+        //         w.r.t. each other.
+        let seenFunctionScope = false;
+        const result = [];
+        // Walk the original scope chain outwards and try to find the corresponding generated range along the way.
+        for (let originalScope = rangeChain.at(-1)?.originalScope; originalScope; originalScope = originalScope.parent) {
+            const range = rangeChain.findLast(r => r.originalScope === originalScope);
+            const isFunctionScope = originalScope.kind === 'function';
+            const isInnerMostFunction = isFunctionScope && !seenFunctionScope;
+            const returnValue = isInnerMostFunction ? callFrame.returnValue() : null;
+            result.push(new SourceMapScopeChainEntry(callFrame, originalScope, range, isInnerMostFunction, returnValue ?? undefined));
+            seenFunctionScope ||= isFunctionScope;
+        }
+        // If we are paused on a return statement, we need to drop inner block scopes. This is because V8 only emits a
+        // single return bytecode and "gotos" at the functions' end, where we are now paused.
+        if (callFrame.returnValue() !== null) {
+            while (result.length && result[0].type() !== "local" /* Protocol.Debugger.ScopeType.Local */) {
+                result.shift();
+            }
+        }
+        return result;
+    }
+    /** Similar to #findGeneratedRangeChain, but takes inlineFrameIndex of virtual call frames into account */
+    #findGeneratedRangeChainForFrame(callFrame) {
+        const rangeChain = this.#findGeneratedRangeChain(callFrame.location().lineNumber, callFrame.location().columnNumber);
+        if (callFrame.inlineFrameIndex === 0) {
+            return rangeChain;
+        }
+        // Drop ranges in the chain until we reach our desired inlined range.
+        for (let inlineIndex = 0; inlineIndex < callFrame.inlineFrameIndex;) {
+            const range = rangeChain.pop();
+            if (range?.callSite) {
+                ++inlineIndex;
+            }
+        }
+        return rangeChain;
+    }
+    /**
+     * Returns the authored function name of the function containing the provided generated position.
+     */
+    findOriginalFunctionName({ line, column }) {
+        // There are 2 approaches:
+        //   1) Find the inner-most generated range containing the provided generated position
+        //      and use it's OriginalScope (then walk it outwards until we hit a function).
+        //   2) Use the mappings to turn the generated position into an original position.
+        //      Then find the inner-most original scope containing that original position.
+        //      Then walk it outwards until we hit a function.
+        //
+        // Both approaches should yield the same result (assuming the mappings are spec compliant
+        // w.r.t. generated ranges). But in the case of "pasta" scopes and extension provided
+        // scope info, we only have the OriginalScope parts and mappings without GeneratedRanges.
+        let originalInnerMostScope;
+        if (this.#generatedRanges.length > 0) {
+            const rangeChain = this.#findGeneratedRangeChain(line, column);
+            originalInnerMostScope = rangeChain.at(-1)?.originalScope;
+        }
+        else {
+            // No GeneratedRanges. Try to use mappings.
+            const entry = this.#sourceMap.findEntry(line, column);
+            if (entry?.sourceIndex === undefined) {
+                return null;
+            }
+            originalInnerMostScope =
+                this.#findOriginalScopeChain({ sourceIndex: entry.sourceIndex, line: entry.sourceLineNumber, column: entry.sourceColumnNumber })
+                    .at(-1);
+        }
+        // Walk the original scope chain outwards until we find a function.
+        for (let originalScope = originalInnerMostScope; originalScope; originalScope = originalScope.parent) {
+            if (originalScope.isStackFrame) {
+                return originalScope.name ?? '';
+            }
+        }
+        return null;
+    }
+    /**
+     * Given an original position, this returns all the surrounding original scopes from outer
+     * to inner.
+     */
+    #findOriginalScopeChain({ sourceIndex, line, column }) {
+        const scope = this.#originalScopes[sourceIndex];
+        if (!scope) {
+            return [];
+        }
+        const result = [];
+        (function walkScopes(scopes) {
+            for (const scope of scopes) {
+                if (!contains(scope, line, column)) {
+                    continue;
+                }
+                result.push(scope);
+                walkScopes(scope.children);
+            }
+        })([scope]);
+        return result;
+    }
+}
+export function contains(range, line, column) {
+    if (range.start.line > line || (range.start.line === line && range.start.column > column)) {
+        return false;
+    }
+    if (range.end.line < line || (range.end.line === line && range.end.column <= column)) {
+        return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,143 @@
+// 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 { SDKModel } from './SDKModel.js';
+import { StorageKeyManager } from './StorageKeyManager.js';
+export class StorageBucketsModel extends SDKModel {
+    enabled = false;
+    storageAgent;
+    storageKeyManager;
+    bucketsById = new Map();
+    trackedStorageKeys = new Set();
+    constructor(target) {
+        super(target);
+        target.registerStorageDispatcher(this);
+        this.storageAgent = target.storageAgent();
+        this.storageKeyManager = target.model(StorageKeyManager);
+    }
+    getBuckets() {
+        return new Set(this.bucketsById.values());
+    }
+    getBucketsForStorageKey(storageKey) {
+        const buckets = [...this.bucketsById.values()];
+        return new Set(buckets.filter(({ bucket }) => bucket.storageKey === storageKey));
+    }
+    getDefaultBucketForStorageKey(storageKey) {
+        const buckets = [...this.bucketsById.values()];
+        return buckets.find(({ bucket }) => bucket.storageKey === storageKey && bucket.name === undefined) ?? null;
+    }
+    getBucketById(bucketId) {
+        return this.bucketsById.get(bucketId) ?? null;
+    }
+    getBucketByName(storageKey, bucketName) {
+        if (!bucketName) {
+            return this.getDefaultBucketForStorageKey(storageKey);
+        }
+        const buckets = [...this.bucketsById.values()];
+        return buckets.find(({ bucket }) => bucket.storageKey === storageKey && bucket.name === bucketName) ?? null;
+    }
+    deleteBucket(bucket) {
+        void this.storageAgent.invoke_deleteStorageBucket({ bucket });
+    }
+    enable() {
+        if (this.enabled) {
+            return;
+        }
+        if (this.storageKeyManager) {
+            this.storageKeyManager.addEventListener("StorageKeyAdded" /* StorageKeyManagerEvents.STORAGE_KEY_ADDED */, this.storageKeyAdded, this);
+            this.storageKeyManager.addEventListener("StorageKeyRemoved" /* StorageKeyManagerEvents.STORAGE_KEY_REMOVED */, this.storageKeyRemoved, this);
+            for (const storageKey of this.storageKeyManager.storageKeys()) {
+                this.addStorageKey(storageKey);
+            }
+        }
+        this.enabled = true;
+    }
+    storageKeyAdded(event) {
+        this.addStorageKey(event.data);
+    }
+    storageKeyRemoved(event) {
+        this.removeStorageKey(event.data);
+    }
+    addStorageKey(storageKey) {
+        if (this.trackedStorageKeys.has(storageKey)) {
+            throw new Error('Can\'t call addStorageKey for a storage key if it has already been added.');
+        }
+        this.trackedStorageKeys.add(storageKey);
+        void this.storageAgent.invoke_setStorageBucketTracking({ storageKey, enable: true });
+    }
+    removeStorageKey(storageKey) {
+        if (!this.trackedStorageKeys.has(storageKey)) {
+            throw new Error('Can\'t call removeStorageKey for a storage key if it hasn\'t already been added.');
+        }
+        const bucketsForStorageKey = this.getBucketsForStorageKey(storageKey);
+        for (const bucket of bucketsForStorageKey) {
+            this.bucketRemoved(bucket);
+        }
+        this.trackedStorageKeys.delete(storageKey);
+        void this.storageAgent.invoke_setStorageBucketTracking({ storageKey, enable: false });
+    }
+    bucketAdded(bucketInfo) {
+        this.bucketsById.set(bucketInfo.id, bucketInfo);
+        this.dispatchEventToListeners("BucketAdded" /* Events.BUCKET_ADDED */, { model: this, bucketInfo });
+    }
+    bucketRemoved(bucketInfo) {
+        this.bucketsById.delete(bucketInfo.id);
+        this.dispatchEventToListeners("BucketRemoved" /* Events.BUCKET_REMOVED */, { model: this, bucketInfo });
+    }
+    bucketChanged(bucketInfo) {
+        this.dispatchEventToListeners("BucketChanged" /* Events.BUCKET_CHANGED */, { model: this, bucketInfo });
+    }
+    bucketInfosAreEqual(bucketInfo1, bucketInfo2) {
+        return bucketInfo1.bucket.storageKey === bucketInfo2.bucket.storageKey && bucketInfo1.id === bucketInfo2.id &&
+            bucketInfo1.bucket.name === bucketInfo2.bucket.name && bucketInfo1.expiration === bucketInfo2.expiration &&
+            bucketInfo1.quota === bucketInfo2.quota && bucketInfo1.persistent === bucketInfo2.persistent &&
+            bucketInfo1.durability === bucketInfo2.durability;
+    }
+    storageBucketCreatedOrUpdated({ bucketInfo }) {
+        const curBucket = this.getBucketById(bucketInfo.id);
+        if (curBucket) {
+            if (!this.bucketInfosAreEqual(curBucket, bucketInfo)) {
+                this.bucketChanged(bucketInfo);
+            }
+        }
+        else {
+            this.bucketAdded(bucketInfo);
+        }
+    }
+    storageBucketDeleted({ bucketId }) {
+        const curBucket = this.getBucketById(bucketId);
+        if (curBucket) {
+            this.bucketRemoved(curBucket);
+        }
+        else {
+            throw new Error(`Received an event that Storage Bucket '${bucketId}' was deleted, but it wasn't in the StorageBucketsModel.`);
+        }
+    }
+    attributionReportingTriggerRegistered(_event) {
+    }
+    interestGroupAccessed(_event) {
+    }
+    interestGroupAuctionEventOccurred(_event) {
+    }
+    interestGroupAuctionNetworkRequestCreated(_event) {
+    }
+    indexedDBListUpdated(_event) {
+    }
+    indexedDBContentUpdated(_event) {
+    }
+    cacheStorageListUpdated(_event) {
+    }
+    cacheStorageContentUpdated(_event) {
+    }
+    sharedStorageAccessed(_event) {
+    }
+    sharedStorageWorkletOperationExecutionFinished(_event) {
+    }
+    attributionReportingSourceRegistered(_event) {
+    }
+    attributionReportingReportSent(_event) {
+    }
+    attributionReportingVerboseDebugReportSent(_event) {
+    }
+}
+SDKModel.register(StorageBucketsModel, { capabilities: 8192 /* Capability.STORAGE */, autostart: false });

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

@@ -0,0 +1,53 @@
+// Copyright 2022 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 { SDKModel } from './SDKModel.js';
+export class StorageKeyManager extends SDKModel {
+    #mainStorageKey;
+    #storageKeys;
+    constructor(target) {
+        super(target);
+        this.#mainStorageKey = '';
+        this.#storageKeys = new Set();
+    }
+    updateStorageKeys(storageKeys) {
+        const oldStorageKeys = this.#storageKeys;
+        this.#storageKeys = storageKeys;
+        for (const storageKey of oldStorageKeys) {
+            if (!this.#storageKeys.has(storageKey)) {
+                this.dispatchEventToListeners("StorageKeyRemoved" /* Events.STORAGE_KEY_REMOVED */, storageKey);
+            }
+        }
+        for (const storageKey of this.#storageKeys) {
+            if (!oldStorageKeys.has(storageKey)) {
+                this.dispatchEventToListeners("StorageKeyAdded" /* Events.STORAGE_KEY_ADDED */, storageKey);
+            }
+        }
+    }
+    storageKeys() {
+        return [...this.#storageKeys];
+    }
+    mainStorageKey() {
+        return this.#mainStorageKey;
+    }
+    setMainStorageKey(storageKey) {
+        this.#mainStorageKey = storageKey;
+        this.dispatchEventToListeners("MainStorageKeyChanged" /* Events.MAIN_STORAGE_KEY_CHANGED */, {
+            mainStorageKey: this.#mainStorageKey,
+        });
+    }
+}
+export function parseStorageKey(storageKeyString) {
+    // Based on the canonical implementation of StorageKey::Deserialize in
+    // third_party/blink/common/storage_key/storage_key.cc
+    const components = storageKeyString.split('^');
+    const origin = Common.ParsedURL.ParsedURL.extractOrigin(components[0]);
+    const storageKey = { origin, components: new Map() };
+    for (let i = 1; i < components.length; ++i) {
+        storageKey.components.set(components[i].charAt(0), components[i].substring(1));
+    }
+    return storageKey;
+}
+// TODO(jarhar): this is the one of the two usages of Capability.None. Do something about it!
+SDKModel.register(StorageKeyManager, { capabilities: 0 /* Capability.NONE */, autostart: false });