@mcp-b/chrome-devtools-mcp 1.1.0 → 1.1.1

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

@@ -0,0 +1,57 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+/** A thin wrapper around the Cache API to store source map JSONs keyed on Debug IDs */
+export class SourceMapCache {
+    static #INSTANCE = new SourceMapCache('devtools-source-map-cache');
+    static instance() {
+        if (typeof window === 'undefined') {
+            // TODO(crbug.com/451502260): Move this behind a `HostRuntime` interface.
+            return IN_MEMORY_INSTANCE; // TS doesn't like that our in-memory class doesn't have the same private fields.
+        }
+        return this.#INSTANCE;
+    }
+    static createForTest(name) {
+        return new SourceMapCache(name);
+    }
+    #name;
+    #cachePromise;
+    constructor(name) {
+        this.#name = name;
+    }
+    async set(debugId, sourceMap) {
+        const cache = await this.#cache();
+        await cache.put(SourceMapCache.#urlForDebugId(debugId), new Response(JSON.stringify(sourceMap)));
+    }
+    async get(debugId) {
+        const cache = await this.#cache();
+        const response = await cache.match(SourceMapCache.#urlForDebugId(debugId));
+        return await response?.json() ?? null;
+    }
+    async #cache() {
+        if (this.#cachePromise) {
+            return await this.#cachePromise;
+        }
+        this.#cachePromise = window.caches.open(this.#name);
+        return await this.#cachePromise;
+    }
+    /** The Cache API only allows URL as keys, so we construct a simple one. Given that we have our own cache, we have no risk of conflicting URLs */
+    static #urlForDebugId(debugId) {
+        return 'http://debug.id/' + encodeURIComponent(debugId);
+    }
+    async disposeForTest() {
+        await window.caches.delete(this.#name);
+    }
+}
+const IN_MEMORY_INSTANCE = new (class {
+    #cache = new Map();
+    async set(debugId, sourceMap) {
+        this.#cache.set(debugId, sourceMap);
+    }
+    async get(debugId) {
+        return this.#cache.get(debugId) ?? null;
+    }
+    async disposeForTest() {
+        // Do nothing.
+    }
+})();

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

@@ -0,0 +1,132 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { TokenIterator } from './SourceMap.js';
+/**
+ * Turns a list of {@link NamedFunctionRange}s into a single {@link OriginalScope} tree nested
+ * according to the start/end position. Each range is turned into a OriginalScope with the `isStackFrame`
+ * bit set to denote it as a function and a generic "Function" label.
+ *
+ * We nest all these function scopes underneath a single global scope that always starts at (0, 0) and
+ * reaches to the largest end position.
+ *
+ * `ranges` can be unsorted but will be sorted in-place.
+ *
+ * @throws if the ranges are not nested properly. Concretely: start < end for each range, and no
+ * "straddling" (i.e. partially overlapping ranges).
+ */
+export function buildOriginalScopes(ranges) {
+    validateStartBeforeEnd(ranges);
+    // 1. Sort ranges by ascending start position.
+    //    If two ranges have the same start position, we sort the one
+    //    with the higher end position first, because it's the parent.
+    ranges.sort((a, b) => comparePositions(a.start, b.start) || comparePositions(b.end, a.end));
+    const root = {
+        start: { line: 0, column: 0 },
+        end: { line: Number.POSITIVE_INFINITY, column: Number.POSITIVE_INFINITY },
+        kind: 'Global',
+        isStackFrame: false,
+        children: [],
+        variables: [],
+    };
+    // 2. Build the tree from the ranges.
+    const stack = [root];
+    for (const range of ranges) {
+        // Pop all scopes that precede the current entry (to find the right parent).
+        let stackTop = stack.at(-1);
+        while (true) {
+            if (comparePositions(stackTop.end, range.start) <= 0) {
+                stack.pop();
+                stackTop = stack.at(-1);
+            }
+            else {
+                break;
+            }
+        }
+        /*
+         * Check for partially overlapping ranges:
+         *
+         * --- A
+         *  |  --- B
+         * ---  |
+         *     ---
+         *
+         *i.e.: B.start < A.end < B.end
+         */
+        if (comparePositions(range.start, stackTop.end) < 0 && comparePositions(stackTop.end, range.end) < 0) {
+            throw new Error(`Range ${JSON.stringify(range)} and ${JSON.stringify(stackTop)} partially overlap.`);
+        }
+        const scope = createScopeFrom(range);
+        stackTop.children.push(scope);
+        stack.push(scope);
+    }
+    // 3. Update root.end.
+    const lastChild = root.children.at(-1);
+    if (lastChild) {
+        root.end = lastChild.end;
+    }
+    return root;
+}
+function validateStartBeforeEnd(ranges) {
+    for (const range of ranges) {
+        if (comparePositions(range.start, range.end) >= 0) {
+            throw new Error(`Invalid range. End before start: ${JSON.stringify(range)}`);
+        }
+    }
+}
+function createScopeFrom(range) {
+    return {
+        ...range,
+        kind: 'Function',
+        isStackFrame: true,
+        children: [],
+        variables: [],
+    };
+}
+/**
+ * Implements decoding of the pasta source map specification.
+ *
+ * See https://github.com/bloomberg/pasta-sourcemaps/blob/main/spec.md
+ */
+export function decodePastaRanges(encodedRanges, names) {
+    const result = [];
+    let nameIndex = 0;
+    let startLineNumber = 0;
+    let startColumnNumber = 0;
+    let endLineNumber = 0;
+    let endColumnNumber = 0;
+    const tokenIter = new TokenIterator(encodedRanges);
+    let atStart = true;
+    while (tokenIter.hasNext()) {
+        if (atStart) {
+            atStart = false;
+        }
+        else if (tokenIter.peek() === ',') {
+            tokenIter.next();
+        }
+        else {
+            // Unexpected character. Return what we have up until now.
+            break;
+        }
+        nameIndex += tokenIter.nextVLQ();
+        startLineNumber = endLineNumber + tokenIter.nextVLQ();
+        startColumnNumber += tokenIter.nextVLQ();
+        endLineNumber = startLineNumber + tokenIter.nextVLQ();
+        endColumnNumber += tokenIter.nextVLQ();
+        const name = names[nameIndex];
+        if (name === undefined) {
+            // If the range doesn't have a valid name, ignore it.
+            continue;
+        }
+        result.push({
+            start: { line: startLineNumber, column: startColumnNumber },
+            end: { line: endLineNumber, column: endColumnNumber },
+            name,
+        });
+    }
+    return result;
+}
+/** @returns 0 if both positions are equal, a negative number if a < b and a positive number if a > b */
+function comparePositions(a, b) {
+    return a.line - b.line || a.column - b.column;
+}

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

@@ -0,0 +1,201 @@
+// 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 Common from '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import { PageResourceLoader } from './PageResourceLoader.js';
+import { parseSourceMap, SourceMap } from './SourceMap.js';
+import { SourceMapCache } from './SourceMapCache.js';
+import { Type } from './Target.js';
+export class SourceMapManager extends Common.ObjectWrapper.ObjectWrapper {
+    #target;
+    #factory;
+    #isEnabled = true;
+    #clientData = new Map();
+    #sourceMaps = new Map();
+    #attachingClient = null;
+    constructor(target, factory) {
+        super();
+        this.#target = target;
+        this.#factory =
+            factory ?? ((compiledURL, sourceMappingURL, payload) => new SourceMap(compiledURL, sourceMappingURL, payload));
+    }
+    setEnabled(isEnabled) {
+        if (isEnabled === this.#isEnabled) {
+            return;
+        }
+        // We need this copy, because `this.#clientData` is getting modified
+        // in the loop body and trying to iterate over it at the same time
+        // leads to an infinite loop.
+        const clientData = [...this.#clientData.entries()];
+        for (const [client] of clientData) {
+            this.detachSourceMap(client);
+        }
+        this.#isEnabled = isEnabled;
+        for (const [client, { relativeSourceURL, relativeSourceMapURL }] of clientData) {
+            this.attachSourceMap(client, relativeSourceURL, relativeSourceMapURL);
+        }
+    }
+    static getBaseUrl(target) {
+        while (target && target.type() !== Type.FRAME) {
+            target = target.parentTarget();
+        }
+        return target?.inspectedURL() ?? Platform.DevToolsPath.EmptyUrlString;
+    }
+    static resolveRelativeSourceURL(target, url) {
+        url = Common.ParsedURL.ParsedURL.completeURL(SourceMapManager.getBaseUrl(target), url) ?? url;
+        return url;
+    }
+    sourceMapForClient(client) {
+        return this.#clientData.get(client)?.sourceMap;
+    }
+    // This method actively awaits the source map, if still loading.
+    sourceMapForClientPromise(client) {
+        const clientData = this.#clientData.get(client);
+        if (!clientData) {
+            return Promise.resolve(undefined);
+        }
+        return clientData.sourceMapPromise;
+    }
+    clientForSourceMap(sourceMap) {
+        return this.#sourceMaps.get(sourceMap);
+    }
+    // TODO(bmeurer): We are lying about the type of |relativeSourceURL| here.
+    attachSourceMap(client, relativeSourceURL, relativeSourceMapURL) {
+        if (this.#clientData.has(client)) {
+            throw new Error('SourceMap is already attached or being attached to client');
+        }
+        if (!relativeSourceMapURL) {
+            return;
+        }
+        let clientData = {
+            relativeSourceURL,
+            relativeSourceMapURL,
+            sourceMap: undefined,
+            sourceMapPromise: Promise.resolve(undefined),
+        };
+        if (this.#isEnabled) {
+            // The `// #sourceURL=foo` can be a random string, but is generally an absolute path.
+            // Complete it to inspected page url for relative links.
+            const sourceURL = SourceMapManager.resolveRelativeSourceURL(this.#target, relativeSourceURL);
+            const sourceMapURL = Common.ParsedURL.ParsedURL.completeURL(sourceURL, relativeSourceMapURL);
+            if (sourceMapURL) {
+                if (this.#attachingClient) {
+                    // This should not happen
+                    console.error('Attaching source map may cancel previously attaching source map');
+                }
+                this.#attachingClient = client;
+                this.dispatchEventToListeners(Events.SourceMapWillAttach, { client });
+                if (this.#attachingClient === client) {
+                    this.#attachingClient = null;
+                    const initiator = client.createPageResourceLoadInitiator();
+                    // TODO(crbug.com/458180550): Pass PageResourceLoader via constructor.
+                    //     The reason we grab it here lazily from the context is that otherwise every
+                    //     unit test using `createTarget` would need to set up a `PageResourceLoader`, as
+                    //     CSSModel and DebuggerModel are autostarted by default, and they create a
+                    //     SourceMapManager in their respective constructors.
+                    const resourceLoader = this.#target.targetManager().context.get(PageResourceLoader);
+                    clientData.sourceMapPromise =
+                        loadSourceMap(resourceLoader, sourceMapURL, client.debugId(), initiator)
+                            .then(payload => {
+                            const sourceMap = this.#factory(sourceURL, sourceMapURL, payload, client);
+                            if (this.#clientData.get(client) === clientData) {
+                                clientData.sourceMap = sourceMap;
+                                this.#sourceMaps.set(sourceMap, client);
+                                this.dispatchEventToListeners(Events.SourceMapAttached, { client, sourceMap });
+                            }
+                            return sourceMap;
+                        }, () => {
+                            if (this.#clientData.get(client) === clientData) {
+                                this.dispatchEventToListeners(Events.SourceMapFailedToAttach, { client });
+                            }
+                            return undefined;
+                        });
+                }
+                else {
+                    // Assume cancelAttachSourceMap was called.
+                    if (this.#attachingClient) {
+                        // This should not happen
+                        console.error('Cancelling source map attach because another source map is attaching');
+                    }
+                    clientData = null;
+                    this.dispatchEventToListeners(Events.SourceMapFailedToAttach, { client });
+                }
+            }
+        }
+        if (clientData) {
+            this.#clientData.set(client, clientData);
+        }
+    }
+    cancelAttachSourceMap(client) {
+        if (client === this.#attachingClient) {
+            this.#attachingClient = null;
+            // This should not happen.
+        }
+        else if (this.#attachingClient) {
+            console.error('cancel attach source map requested but a different source map was being attached');
+        }
+        else {
+            console.error('cancel attach source map requested but no source map was being attached');
+        }
+    }
+    detachSourceMap(client) {
+        const clientData = this.#clientData.get(client);
+        if (!clientData) {
+            return;
+        }
+        this.#clientData.delete(client);
+        if (!this.#isEnabled) {
+            return;
+        }
+        const { sourceMap } = clientData;
+        if (sourceMap) {
+            this.#sourceMaps.delete(sourceMap);
+            this.dispatchEventToListeners(Events.SourceMapDetached, { client, sourceMap });
+        }
+        else {
+            this.dispatchEventToListeners(Events.SourceMapFailedToAttach, { client });
+        }
+    }
+    waitForSourceMapsProcessedForTest() {
+        return Promise.all(this.#sourceMaps.keys().map(sourceMap => sourceMap.scopesFallbackPromiseForTest));
+    }
+}
+async function loadSourceMap(resourceLoader, url, debugId, initiator) {
+    try {
+        if (debugId) {
+            const cachedSourceMap = await SourceMapCache.instance().get(debugId);
+            if (cachedSourceMap) {
+                return cachedSourceMap;
+            }
+        }
+        const { content } = await resourceLoader.loadResource(url, initiator);
+        const sourceMap = parseSourceMap(content);
+        if ('debugId' in sourceMap && sourceMap.debugId) {
+            // In case something goes wrong with updating the cache, we still want to use the source map.
+            await SourceMapCache.instance().set(sourceMap.debugId, sourceMap).catch();
+        }
+        return sourceMap;
+    }
+    catch (cause) {
+        throw new Error(`Could not load content for ${url}: ${cause.message}`, { cause });
+    }
+}
+export async function tryLoadSourceMap(resourceLoader, url, initiator) {
+    try {
+        return await loadSourceMap(resourceLoader, url, null, initiator);
+    }
+    catch (cause) {
+        console.error(cause);
+        return null;
+    }
+}
+export var Events;
+(function (Events) {
+    /* eslint-disable @typescript-eslint/naming-convention -- Used by web_tests. */
+    Events["SourceMapWillAttach"] = "SourceMapWillAttach";
+    Events["SourceMapFailedToAttach"] = "SourceMapFailedToAttach";
+    Events["SourceMapAttached"] = "SourceMapAttached";
+    Events["SourceMapDetached"] = "SourceMapDetached";
+    /* eslint-enable @typescript-eslint/naming-convention */
+})(Events || (Events = {}));

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

@@ -0,0 +1,156 @@
+// 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 i18n from '../i18n/i18n.js';
+import { RemoteObjectImpl, RemoteObjectProperty } from './RemoteObject.js';
+import { contains } from './SourceMapScopesInfo.js';
+const UIStrings = {
+    /**
+     * @description Title of a section in the debugger showing local JavaScript variables.
+     */
+    local: 'Local',
+    /**
+     * @description Text that refers to closure as a programming term
+     */
+    closure: 'Closure',
+    /**
+     * @description Noun that represents a section or block of code in the Debugger Model. Shown in the Sources tab, while paused on a breakpoint.
+     */
+    block: 'Block',
+    /**
+     * @description Title of a section in the debugger showing JavaScript variables from the global scope.
+     */
+    global: 'Global',
+    /**
+     * @description Text in Scope Chain Sidebar Pane of the Sources panel
+     */
+    returnValue: 'Return value',
+};
+const str_ = i18n.i18n.registerUIStrings('core/sdk/SourceMapScopeChainEntry.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class SourceMapScopeChainEntry {
+    #callFrame;
+    #scope;
+    #range;
+    #isInnerMostFunction;
+    #returnValue;
+    /**
+     * @param isInnerMostFunction If `scope` is the innermost 'function' scope. Only used for labeling as we name the
+     * scope of the paused function 'Local', while other outer 'function' scopes are named 'Closure'.
+     */
+    constructor(callFrame, scope, range, isInnerMostFunction, returnValue) {
+        this.#callFrame = callFrame;
+        this.#scope = scope;
+        this.#range = range;
+        this.#isInnerMostFunction = isInnerMostFunction;
+        this.#returnValue = returnValue;
+    }
+    extraProperties() {
+        if (this.#returnValue) {
+            return [new RemoteObjectProperty(i18nString(UIStrings.returnValue), this.#returnValue, undefined, undefined, undefined, undefined, undefined, 
+                /* synthetic */ true)];
+        }
+        return [];
+    }
+    callFrame() {
+        return this.#callFrame;
+    }
+    type() {
+        switch (this.#scope.kind) {
+            case 'global':
+                return "global" /* Protocol.Debugger.ScopeType.Global */;
+            case 'function':
+                return this.#isInnerMostFunction ? "local" /* Protocol.Debugger.ScopeType.Local */ : "closure" /* Protocol.Debugger.ScopeType.Closure */;
+            case 'block':
+                return "block" /* Protocol.Debugger.ScopeType.Block */;
+        }
+        return this.#scope.kind ?? '';
+    }
+    typeName() {
+        switch (this.#scope.kind) {
+            case 'global':
+                return i18nString(UIStrings.global);
+            case 'function':
+                return this.#isInnerMostFunction ? i18nString(UIStrings.local) : i18nString(UIStrings.closure);
+            case 'block':
+                return i18nString(UIStrings.block);
+        }
+        return this.#scope.kind ?? '';
+    }
+    name() {
+        return this.#scope.name;
+    }
+    range() {
+        return null;
+    }
+    object() {
+        return new SourceMapScopeRemoteObject(this.#callFrame, this.#scope, this.#range);
+    }
+    description() {
+        return '';
+    }
+    icon() {
+        return undefined;
+    }
+}
+class SourceMapScopeRemoteObject extends RemoteObjectImpl {
+    #callFrame;
+    #scope;
+    #range;
+    constructor(callFrame, scope, range) {
+        super(callFrame.debuggerModel.runtimeModel(), /* objectId */ undefined, 'object', /* sub type */ undefined, 
+        /* value */ null);
+        this.#callFrame = callFrame;
+        this.#scope = scope;
+        this.#range = range;
+    }
+    async doGetProperties(_ownProperties, accessorPropertiesOnly, generatePreview) {
+        if (accessorPropertiesOnly) {
+            return { properties: [], internalProperties: [] };
+        }
+        const properties = [];
+        for (const [index, variable] of this.#scope.variables.entries()) {
+            const expression = this.#findExpression(index);
+            if (expression === null) {
+                properties.push(SourceMapScopeRemoteObject.#unavailableProperty(variable));
+                continue;
+            }
+            // TODO(crbug.com/40277685): Once we can evaluate expressions in scopes other than the innermost one,
+            //         we need to find the find the CDP scope that matches `this.#range` and evaluate in that.
+            const result = await this.#callFrame.evaluate({ expression, generatePreview });
+            if ('error' in result || result.exceptionDetails) {
+                // TODO(crbug.com/40277685): Make these errors user-visible to aid tooling developers.
+                //         E.g. show the error on hover or expose it in the developer resources panel.
+                properties.push(SourceMapScopeRemoteObject.#unavailableProperty(variable));
+            }
+            else {
+                properties.push(new RemoteObjectProperty(variable, result.object, /* enumerable */ false, /* writable */ false, /* isOwn */ true, 
+                /* wasThrown */ false));
+            }
+        }
+        return { properties, internalProperties: [] };
+    }
+    /** @returns null if the variable is unavailable at the current paused location */
+    #findExpression(index) {
+        if (!this.#range) {
+            return null;
+        }
+        const expressionOrSubRanges = this.#range.values[index];
+        if (typeof expressionOrSubRanges === 'string') {
+            return expressionOrSubRanges;
+        }
+        if (expressionOrSubRanges === null) {
+            return null;
+        }
+        const pausedPosition = this.#callFrame.location();
+        for (const range of expressionOrSubRanges) {
+            if (contains({ start: range.from, end: range.to }, pausedPosition.lineNumber, pausedPosition.columnNumber)) {
+                return range.value ?? null;
+            }
+        }
+        return null;
+    }
+    static #unavailableProperty(name) {
+        return new RemoteObjectProperty(name, null, /* enumerable */ false, /* writeable */ false, /* isOwn */ true, /* wasThrown */ false);
+    }
+}