chrome-devtools-mcp-for-extension 0.19.2 → 0.20.0

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

@@ -86,7 +86,8 @@ export class ResourceTreeModel extends SDKModel {
         if (!this.framesInternal.has(frameId)) {
             return null;
         }
-        const response = await this.storageAgent.invoke_getStorageKeyForFrame({ frameId });
+        // TODO(crbug.com/445966299): Refactor to use `storageAgent().invoke_getStorageKey()` instead.
+        const response = await this.storageAgent.invoke_getStorageKey({ frameId });
         if (response.getError() === 'Frame tree node for given frame not found') {
             return null;
         }
@@ -721,7 +722,7 @@ export class ResourceTreeFrame {
     }
     addRequest(request) {
         let resource = this.resourcesMap.get(request.url());
-        if (resource && resource.request === request) {
+        if (resource?.request === request) {
             // Already in the tree, we just got an extra update.
             return;
         }

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

@@ -0,0 +1,36 @@
+// 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 Formatter from '../../models/formatter/formatter.js';
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+/** If a script failed to parse, we stash null in order to prevent unnecessary re-parsing */
+const scopeTrees = new WeakMap();
+/**
+ * Computes and caches the scope tree for `script`.
+ *
+ * We use {@link Script} as a key to uniquely identify scripts.
+ * {@link Script} boils down to "target" + "script ID". This
+ * duplicates work in case of identical script running on multiple targets
+ * (e.g. workers).
+ *
+ * We also return a {@link TextUtils.Text.Text} instance. The scope tree uses offsets
+ * and the text allows conversion from/to line/column numbers.
+ */
+export function scopeTreeForScript(script) {
+    let promise = scopeTrees.get(script);
+    if (promise === undefined) {
+        promise = script.requestContentData().then(content => {
+            if (TextUtils.ContentData.ContentData.isError(content)) {
+                return null;
+            }
+            const sourceType = script.isModule ? 'module' : 'script';
+            return Formatter.FormatterWorkerPool.formatterWorkerPool()
+                .javaScriptScopeTree(content.text, sourceType)
+                .then(scopeTree => scopeTree ? ({ scopeTree, text: content.textObj }) : null)
+                .catch(() => null);
+        });
+        scopeTrees.set(script, promise);
+    }
+    // We intentionally return `null` here if the script already failed to parse once.
+    return promise;
+}

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

@@ -3,24 +3,26 @@
 // found in the LICENSE file.
 import { OverlayModel } from './OverlayModel.js';
 import { SDKModel } from './SDKModel.js';
-// Manages concurrent screencast requests by queuing and prioritizing.
-//
-// When startScreencast is invoked:
-//   - If a screencast is currently active, the existing screencast's parameters and callbacks are
-//     saved in the #screencastOperations array.
-//   - The active screencast is then stopped.
-//   - A new screencast is initiated using the parameters and callbacks from the current startScreencast call.
-//
-// When stopScreencast is invoked:
-//   - The currently active screencast is stopped.
-//   - The #screencastOperations is checked for interrupted screencast operations.
-//   - If any operations are found, the latest one is started
-//     using its saved parameters and callbacks.
-//
-// This ensures that:
-//   - Only one screencast is active at a time.
-//   - Interrupted screencasts are resumed after the current screencast is stopped.
-// This ensures animation previews, which use screencasting, don't disrupt ongoing remote debugging sessions. Without this mechanism, stopping a preview screencast would terminate the debugging screencast, freezing the ScreencastView.
+/**
+ * Manages concurrent screencast requests by queuing and prioritizing.
+ *
+ * When startScreencast is invoked:
+ * - If a screencast is currently active, the existing screencast's parameters and callbacks are
+ * saved in the #screencastOperations array.
+ * - The active screencast is then stopped.
+ * - A new screencast is initiated using the parameters and callbacks from the current startScreencast call.
+ *
+ * When stopScreencast is invoked:
+ * - The currently active screencast is stopped.
+ * - The #screencastOperations is checked for interrupted screencast operations.
+ * - If any operations are found, the latest one is started
+ * using its saved parameters and callbacks.
+ *
+ * This ensures that:
+ * - Only one screencast is active at a time.
+ * - Interrupted screencasts are resumed after the current screencast is stopped.
+ * This ensures animation previews, which use screencasting, don't disrupt ongoing remote debugging sessions. Without this mechanism, stopping a preview screencast would terminate the debugging screencast, freezing the ScreencastView.
+ **/
 export class ScreenCaptureModel extends SDKModel {
     #agent;
     #nextScreencastOperationId = 1;

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

@@ -1,6 +1,31 @@
 // Copyright 2021 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import * as Platform from '../../core/platform/platform.js';
 import * as TextUtils from '../../models/text_utils/text_utils.js';
 import * as Common from '../common/common.js';
 import * as i18n from '../i18n/i18n.js';
@@ -366,7 +391,7 @@ function frameIdForScript(script) {
 }
 export const sourceURLRegex = /^[\x20\t]*\/\/[@#] sourceURL=\s*(\S*?)\s*$/;
 export async function disassembleWasm(content) {
-    const worker = Common.Worker.WorkerWrapper.fromURL(new URL('../../entrypoints/wasmparser_worker/wasmparser_worker-entrypoint.js', import.meta.url));
+    const worker = Platform.HostRuntime.HOST_RUNTIME.createWorker(new URL('../../entrypoints/wasmparser_worker/wasmparser_worker-entrypoint.js', import.meta.url).toString());
     const promise = new Promise((resolve, reject) => {
         worker.onmessage = ({ data }) => {
             if ('method' in data) {

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

@@ -28,6 +28,9 @@ export class ServerSentEventsParser {
     async addBase64Chunk(raw) {
         await this.#decoder.addBase64Chunk(raw);
     }
+    addTextChunk(chunk) {
+        this.#onTextChunk(chunk);
+    }
     #onTextChunk(chunk) {
         // A line consists of "this.#line" plus a slice of "chunk[start:<next new cr/lf>]".
         let start = 0;

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

@@ -7,6 +7,7 @@ import * as ScopesCodec from '../../third_party/source-map-scopes-codec/source-m
 import * as Common from '../common/common.js';
 import * as Platform from '../platform/platform.js';
 import * as Root from '../root/root.js';
+import { scopeTreeForScript } from './ScopeTreeCache.js';
 import { buildOriginalScopes, decodePastaRanges } from './SourceMapFunctionRanges.js';
 import { SourceMapScopesInfo } from './SourceMapScopesInfo.js';
 /**
@@ -56,22 +57,24 @@ export class SourceMap {
     #compiledURL;
     #sourceMappingURL;
     #baseURL;
-    #mappings;
+    #mappings = null;
     #sourceInfos = [];
     #sourceInfoByURL = new Map();
+    #script;
     #scopesInfo = null;
     #debugId;
+    scopesFallbackPromiseForTest;
     /**
      * Implements Source Map V3 model. See https://github.com/google/closure-compiler/wiki/Source-Maps
      * for format description.
      */
-    constructor(compiledURL, sourceMappingURL, payload) {
+    constructor(compiledURL, sourceMappingURL, payload, script) {
         this.#json = payload;
+        this.#script = script;
         this.#compiledURL = compiledURL;
         this.#sourceMappingURL = sourceMappingURL;
         this.#baseURL = (Common.ParsedURL.schemeIs(sourceMappingURL, 'data:')) ? compiledURL : sourceMappingURL;
         this.#debugId = 'debugId' in payload ? payload.debugId : undefined;
-        this.#mappings = null;
         if ('sections' in this.#json) {
             if (this.#json.sections.find(section => 'url' in section)) {
                 Common.Console.Console.instance().warn(`SourceMap "${sourceMappingURL}" contains unsupported "URL" field in one of its sections.`);
@@ -83,7 +86,7 @@ export class SourceMap {
         return this.#json;
     }
     augmentWithScopes(scriptUrl, ranges) {
-        this.#ensureMappingsProcessed();
+        this.#ensureSourceMapProcessed();
         if (this.#json && this.#json.version > 3) {
             throw new Error('Only support augmenting source maps up to version 3.');
         }
@@ -115,6 +118,9 @@ export class SourceMap {
     debugId() {
         return this.#debugId ?? null;
     }
+    sourceURLForSourceIndex(index) {
+        return this.#sourceInfos[index]?.sourceURL;
+    }
     sourceURLs() {
         return [...this.#sourceInfoByURL.keys()];
     }
@@ -126,11 +132,11 @@ export class SourceMap {
         return entry.content;
     }
     hasScopeInfo() {
-        this.#ensureMappingsProcessed();
-        return this.#scopesInfo !== null;
+        this.#ensureSourceMapProcessed();
+        return this.#scopesInfo !== null && !this.#scopesInfo.isEmpty();
     }
     findEntry(lineNumber, columnNumber, inlineFrameIndex) {
-        this.#ensureMappingsProcessed();
+        this.#ensureSourceMapProcessed();
         if (inlineFrameIndex && this.#scopesInfo !== null) {
             // For inlineFrameIndex != 0 we use the callsite info for the corresponding inlining site.
             // Note that the callsite for "inlineFrameIndex" is actually in the previous frame.
@@ -253,18 +259,36 @@ export class SourceMap {
         return ranges;
     }
     mappings() {
-        this.#ensureMappingsProcessed();
+        this.#ensureSourceMapProcessed();
         return this.#mappings ?? [];
     }
+    /**
+     * If the source map does not contain scope information by itself (e.g. "scopes proposal"
+     * or "pasta" scopes), then we'll use this getter to calculate basic function name information from
+     * the AST and mappings.
+     */
+    async #buildScopesFallback() {
+        const scopeTreeAndText = this.#script ? await scopeTreeForScript(this.#script) : null;
+        if (!scopeTreeAndText) {
+            return null;
+        }
+        const { scopeTree, text } = scopeTreeAndText;
+        return SourceMapScopesInfo.createFromAst(this, scopeTree, text);
+    }
     reversedMappings(sourceURL) {
-        this.#ensureMappingsProcessed();
+        this.#ensureSourceMapProcessed();
         return this.#sourceInfoByURL.get(sourceURL)?.reverseMappings ?? [];
     }
-    #ensureMappingsProcessed() {
+    #ensureSourceMapProcessed() {
         if (this.#mappings === null) {
             this.#mappings = [];
             try {
                 this.eachSection(this.parseMap.bind(this));
+                if (!this.hasScopeInfo()) {
+                    this.scopesFallbackPromiseForTest = this.#buildScopesFallback().then(info => {
+                        this.#scopesInfo = info;
+                    });
+                }
             }
             catch (e) {
                 console.error('Failed to parse source map', e);
@@ -281,7 +305,7 @@ export class SourceMap {
     #computeReverseMappings(mappings) {
         const reverseMappingsPerUrl = new Map();
         for (let i = 0; i < mappings.length; i++) {
-            const entryUrl = mappings[i].sourceURL;
+            const entryUrl = mappings[i]?.sourceURL;
             if (!entryUrl) {
                 continue;
             }
@@ -568,23 +592,39 @@ export class SourceMap {
             this.hasIgnoreListHint(sourceURL) === other.hasIgnoreListHint(sourceURL);
     }
     expandCallFrame(frame) {
-        this.#ensureMappingsProcessed();
+        this.#ensureSourceMapProcessed();
         if (this.#scopesInfo === null) {
             return [frame];
         }
         return this.#scopesInfo.expandCallFrame(frame);
     }
     resolveScopeChain(frame) {
-        this.#ensureMappingsProcessed();
+        this.#ensureSourceMapProcessed();
         if (this.#scopesInfo === null) {
             return null;
         }
         return this.#scopesInfo.resolveMappedScopeChain(frame);
     }
     findOriginalFunctionName(position) {
-        this.#ensureMappingsProcessed();
+        this.#ensureSourceMapProcessed();
         return this.#scopesInfo?.findOriginalFunctionName(position) ?? null;
     }
+    findOriginalFunctionScope(position) {
+        this.#ensureSourceMapProcessed();
+        return this.#scopesInfo?.findOriginalFunctionScope(position) ?? null;
+    }
+    isOutlinedFrame(generatedLine, generatedColumn) {
+        this.#ensureSourceMapProcessed();
+        return this.#scopesInfo?.isOutlinedFrame(generatedLine, generatedColumn) ?? false;
+    }
+    hasInlinedFrames(generatedLine, generatedColumn) {
+        this.#ensureSourceMapProcessed();
+        return this.#scopesInfo?.hasInlinedFrames(generatedLine, generatedColumn) ?? false;
+    }
+    translateCallSite(generatedLine, generatedColumn) {
+        this.#ensureSourceMapProcessed();
+        return this.#scopesInfo?.translateCallSite(generatedLine, generatedColumn) ?? [];
+    }
 }
 _a = SourceMap;
 const VLQ_BASE_SHIFT = 5;

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

@@ -5,6 +5,10 @@
 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) {
@@ -39,3 +43,15 @@ export class SourceMapCache {
         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/SourceMapManager.js

@@ -9,13 +9,16 @@ 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) {
+    constructor(target, factory) {
         super();
         this.#target = target;
+        this.#factory =
+            factory ?? ((compiledURL, sourceMappingURL, payload) => new SourceMap(compiledURL, sourceMappingURL, payload));
     }
     setEnabled(isEnabled) {
         if (isEnabled === this.#isEnabled) {
@@ -86,10 +89,16 @@ export class SourceMapManager extends Common.ObjectWrapper.ObjectWrapper {
                 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(sourceMapURL, client.debugId(), initiator)
+                        loadSourceMap(resourceLoader, sourceMapURL, client.debugId(), initiator)
                             .then(payload => {
-                            const sourceMap = new SourceMap(sourceURL, sourceMapURL, payload);
+                            const sourceMap = this.#factory(sourceURL, sourceMapURL, payload, client);
                             if (this.#clientData.get(client) === clientData) {
                                 clientData.sourceMap = sourceMap;
                                 this.#sourceMaps.set(sourceMap, client);
@@ -148,8 +157,11 @@ export class SourceMapManager extends Common.ObjectWrapper.ObjectWrapper {
             this.dispatchEventToListeners(Events.SourceMapFailedToAttach, { client });
         }
     }
+    waitForSourceMapsProcessedForTest() {
+        return Promise.all(this.#sourceMaps.keys().map(sourceMap => sourceMap.scopesFallbackPromiseForTest));
+    }
 }
-export async function loadSourceMap(url, debugId, initiator) {
+async function loadSourceMap(resourceLoader, url, debugId, initiator) {
     try {
         if (debugId) {
             const cachedSourceMap = await SourceMapCache.instance().get(debugId);
@@ -157,7 +169,7 @@ export async function loadSourceMap(url, debugId, initiator) {
                 return cachedSourceMap;
             }
         }
-        const { content } = await PageResourceLoader.instance().loadResource(url, initiator);
+        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.
@@ -169,9 +181,9 @@ export async function loadSourceMap(url, debugId, initiator) {
         throw new Error(`Could not load content for ${url}: ${cause.message}`, { cause });
     }
 }
-export async function tryLoadSourceMap(url, initiator) {
+export async function tryLoadSourceMap(resourceLoader, url, initiator) {
     try {
-        return await loadSourceMap(url, null, initiator);
+        return await loadSourceMap(resourceLoader, url, null, initiator);
     }
     catch (cause) {
         console.error(cause);