@mcp-b/chrome-devtools-mcp 1.7.0 → 1.7.1

package/build/src/telemetry/watchdog/main.js

@@ -0,0 +1,127 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import process from 'node:process';
+import readline from 'node:readline';
+import { parseArgs } from 'node:util';
+import { logger, flushLogs, saveLogsToFile } from '../../logger.js';
+import { WatchdogMessageType } from '../types.js';
+import { ClearcutSender } from './clearcut-sender.js';
+function parseWatchdogArgs() {
+    const { values } = parseArgs({
+        options: {
+            'parent-pid': { type: 'string' },
+            'app-version': { type: 'string' },
+            'os-type': { type: 'string' },
+            'log-file': { type: 'string' },
+            'clearcut-endpoint': { type: 'string' },
+            'clearcut-force-flush-interval-ms': { type: 'string' },
+            'clearcut-include-pid-header': { type: 'boolean' },
+        },
+        strict: true,
+    });
+    // Verify required arguments
+    const parentPid = parseInt(values['parent-pid'] ?? '', 10);
+    const appVersion = values['app-version'];
+    const osType = parseInt(values['os-type'] ?? '', 10);
+    if (isNaN(parentPid) || !appVersion || isNaN(osType)) {
+        console.error('Invalid arguments provided for watchdog process: ', JSON.stringify({ parentPid, appVersion, osType }));
+        process.exit(1);
+    }
+    // Parse Optional Arguments
+    const logFile = values['log-file'];
+    const clearcutEndpoint = values['clearcut-endpoint'];
+    const clearcutIncludePidHeader = values['clearcut-include-pid-header'];
+    let clearcutForceFlushIntervalMs;
+    if (values['clearcut-force-flush-interval-ms']) {
+        const parsed = parseInt(values['clearcut-force-flush-interval-ms'], 10);
+        if (!isNaN(parsed)) {
+            clearcutForceFlushIntervalMs = parsed;
+        }
+    }
+    return {
+        parentPid,
+        appVersion,
+        osType,
+        logFile,
+        clearcutEndpoint,
+        clearcutForceFlushIntervalMs,
+        clearcutIncludePidHeader,
+    };
+}
+function main() {
+    const { parentPid, appVersion, osType, logFile, clearcutEndpoint, clearcutForceFlushIntervalMs, clearcutIncludePidHeader, } = parseWatchdogArgs();
+    let logStream;
+    if (logFile) {
+        logStream = saveLogsToFile(logFile);
+    }
+    const exit = (code) => {
+        if (!logStream) {
+            process.exit(code);
+        }
+        void flushLogs(logStream).finally(() => {
+            process.exit(code);
+        });
+    };
+    logger('Watchdog started', JSON.stringify({
+        pid: process.pid,
+        parentPid,
+        version: appVersion,
+        osType,
+    }, null, 2));
+    const sender = new ClearcutSender({
+        appVersion,
+        osType: osType,
+        clearcutEndpoint,
+        forceFlushIntervalMs: clearcutForceFlushIntervalMs,
+        includePidHeader: clearcutIncludePidHeader,
+    });
+    let isShuttingDown = false;
+    function onParentDeath(reason) {
+        if (isShuttingDown) {
+            return;
+        }
+        isShuttingDown = true;
+        logger(`Parent death detected (${reason}). Sending shutdown event...`);
+        sender
+            .sendShutdownEvent()
+            .then(() => {
+            logger('Shutdown event sent. Exiting.');
+            exit(0);
+        })
+            .catch(err => {
+            logger('Failed to send shutdown event', err);
+            exit(1);
+        });
+    }
+    process.stdin.on('end', () => onParentDeath('stdin end'));
+    process.stdin.on('close', () => onParentDeath('stdin close'));
+    process.on('disconnect', () => onParentDeath('ipc disconnect'));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        terminal: false,
+    });
+    rl.on('line', line => {
+        try {
+            if (!line.trim()) {
+                return;
+            }
+            const msg = JSON.parse(line);
+            if (msg.type === WatchdogMessageType.LOG_EVENT && msg.payload) {
+                sender.enqueueEvent(msg.payload);
+            }
+        }
+        catch (err) {
+            logger('Failed to parse IPC message', err);
+        }
+    });
+}
+try {
+    main();
+}
+catch (err) {
+    console.error('Watchdog fatal error:', err);
+    process.exit(1);
+}

package/build/src/telemetry/watchdog-client.js

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { logger } from '../logger.js';
+export class WatchdogClient {
+    #childProcess;
+    constructor(config, options) {
+        const watchdogPath = fileURLToPath(new URL('./watchdog/main.js', import.meta.url));
+        const args = [
+            watchdogPath,
+            `--parent-pid=${config.parentPid}`,
+            `--app-version=${config.appVersion}`,
+            `--os-type=${config.osType}`,
+        ];
+        if (config.logFile) {
+            args.push(`--log-file=${config.logFile}`);
+        }
+        if (config.clearcutEndpoint) {
+            args.push(`--clearcut-endpoint=${config.clearcutEndpoint}`);
+        }
+        if (config.clearcutForceFlushIntervalMs) {
+            args.push(`--clearcut-force-flush-interval-ms=${config.clearcutForceFlushIntervalMs}`);
+        }
+        if (config.clearcutIncludePidHeader) {
+            args.push('--clearcut-include-pid-header');
+        }
+        const spawner = options?.spawn ?? spawn;
+        this.#childProcess = spawner(process.execPath, args, {
+            stdio: ['pipe', 'ignore', 'ignore'],
+            detached: true,
+        });
+        this.#childProcess.unref();
+        this.#childProcess.on('error', err => {
+            logger('Watchdog process error:', err);
+        });
+        this.#childProcess.on('exit', (code, signal) => {
+            logger(`Watchdog exited with code ${code} and signal ${signal}`);
+        });
+    }
+    send(message) {
+        if (this.#childProcess.stdin &&
+            !this.#childProcess.stdin.destroyed &&
+            this.#childProcess.pid) {
+            try {
+                const line = JSON.stringify(message) + '\n';
+                this.#childProcess.stdin.write(line);
+            }
+            catch (err) {
+                logger('Failed to write to watchdog stdin', err);
+            }
+        }
+        else {
+            logger('Watchdog stdin not available, dropping message');
+        }
+    }
+}

package/build/src/third_party/devtools-formatter-worker.js

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// eslint-disable-next-line no-restricted-imports
+import '../../vendor/chrome-devtools-frontend/front_end/entrypoints/formatter_worker/formatter_worker-entrypoint.js';

package/build/src/tools/browser.js

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { defineTool } from './ToolDefinition.js';
+export const connectToBrowser = defineTool({
+    name: 'connect_to_browser',
+    description: 'Connect to a different Chrome browser instance at runtime. ' +
+        'Disconnects from the current browser (without closing it) and attaches to the new one. ' +
+        'Useful for WXT extension development: run `wxt dev`, parse the debug URL from stdout, ' +
+        'then call this tool to attach. Retries automatically if the browser is still starting up.',
+    annotations: {
+        title: 'Connect to Browser',
+        category: ToolCategory.NAVIGATION,
+        readOnlyHint: false,
+    },
+    schema: {
+        browserUrl: zod
+            .string()
+            .optional()
+            .describe('HTTP URL to the browser\'s DevTools endpoint, e.g. "http://127.0.0.1:9222". ' +
+            'Exactly one of browserUrl or wsEndpoint is required.'),
+        wsEndpoint: zod
+            .string()
+            .optional()
+            .describe('WebSocket URL to connect to, e.g. "ws://127.0.0.1:9222/devtools/browser/...". ' +
+            'Exactly one of browserUrl or wsEndpoint is required.'),
+        wsHeaders: zod
+            .record(zod.string())
+            .optional()
+            .describe('Optional HTTP headers for WebSocket connection (only used with wsEndpoint).'),
+        timeout: zod
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe('Maximum time in milliseconds to wait for the browser to become available. ' +
+            'Defaults to 30000 (30 seconds). The tool retries every 2 seconds within this window.'),
+    },
+    handler: async (request, response, context) => {
+        const { browserUrl, wsEndpoint, wsHeaders, timeout } = request.params;
+        // Validate: exactly one connection method required
+        if (!browserUrl && !wsEndpoint) {
+            throw new Error('Either browserUrl or wsEndpoint is required. ' +
+                'Example: browserUrl "http://127.0.0.1:9222" or wsEndpoint "ws://127.0.0.1:9222/devtools/browser/..."');
+        }
+        if (browserUrl && wsEndpoint) {
+            throw new Error('Provide only one of browserUrl or wsEndpoint, not both.');
+        }
+        // Validate URL protocols
+        if (browserUrl && !browserUrl.startsWith('http://') && !browserUrl.startsWith('https://')) {
+            throw new Error(`Invalid browserUrl: "${browserUrl}". Must start with http:// or https://`);
+        }
+        if (wsEndpoint && !wsEndpoint.startsWith('ws://') && !wsEndpoint.startsWith('wss://')) {
+            throw new Error(`Invalid wsEndpoint: "${wsEndpoint}". Must start with ws:// or wss://`);
+        }
+        try {
+            const result = await context.reconnectBrowser({
+                browserURL: browserUrl,
+                wsEndpoint,
+                wsHeaders,
+                timeout,
+            });
+            response.appendResponseLine(`Connected to browser at ${wsEndpoint ?? browserUrl}`);
+            response.appendResponseLine(`WebSocket endpoint: ${result.wsEndpoint}`);
+            response.appendResponseLine('');
+            response.appendResponseLine('Pages:');
+            for (const page of result.pages) {
+                const marker = page.selected ? ' (selected)' : '';
+                response.appendResponseLine(`  [${page.index}] ${page.url}${marker}`);
+            }
+        }
+        catch (err) {
+            response.setIsError(true);
+            const message = err instanceof Error ? err.message : String(err);
+            response.appendResponseLine(`Failed to connect: ${message}`);
+            response.appendResponseLine('');
+            response.appendResponseLine('Troubleshooting:');
+            response.appendResponseLine('  - Ensure Chrome was launched with --remote-debugging-port=<port>');
+            response.appendResponseLine('  - Verify the URL is reachable: curl ' + (browserUrl ?? wsEndpoint));
+            if (timeout) {
+                response.appendResponseLine('  - Try increasing the timeout (current: ' + timeout + 'ms)');
+            }
+            else {
+                response.appendResponseLine('  - Try setting a longer timeout (default is 30s)');
+            }
+        }
+    },
+});

package/build/src/tools/extension.js

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { defineTool } from './ToolDefinition.js';
+export const evaluateInExtensionWorker = defineTool({
+    name: 'evaluate_in_extension_worker',
+    description: 'Execute a JavaScript expression in a Chrome extension background service worker. ' +
+        'Useful for inspecting extension state (e.g., McpHub connections, offscreen status) ' +
+        'that is not accessible from page contexts.',
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: false,
+    },
+    schema: {
+        expression: zod
+            .string()
+            .describe('JavaScript expression to evaluate in the service worker.'),
+        extensionId: zod
+            .string()
+            .optional()
+            .describe('Extension ID to target. If omitted, the first extension service worker found is used.'),
+    },
+    handler: async (request, response, context) => {
+        const result = await context.evaluateInExtensionWorker(request.params.expression, request.params.extensionId);
+        response.appendResponseLine(JSON.stringify(result, null, 2));
+    },
+});

package/build/src/tools/extensions.js

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { defineTool } from './ToolDefinition.js';
+const EXTENSIONS_CONDITION = 'experimentalExtensionSupport';
+export const installExtension = defineTool({
+    name: 'install_extension',
+    description: 'Installs a Chrome extension from the given path.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: false,
+        conditions: [EXTENSIONS_CONDITION],
+    },
+    schema: {
+        path: zod
+            .string()
+            .describe('Absolute path to the unpacked extension folder.'),
+    },
+    handler: async (request, response, context) => {
+        const { path } = request.params;
+        const id = await context.installExtension(path);
+        response.appendResponseLine(`Extension installed. Id: ${id}`);
+    },
+});
+export const uninstallExtension = defineTool({
+    name: 'uninstall_extension',
+    description: 'Uninstalls a Chrome extension by its ID.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: false,
+        conditions: [EXTENSIONS_CONDITION],
+    },
+    schema: {
+        id: zod.string().describe('ID of the extension to uninstall.'),
+    },
+    handler: async (request, response, context) => {
+        const { id } = request.params;
+        await context.uninstallExtension(id);
+        response.appendResponseLine(`Extension uninstalled. Id: ${id}`);
+    },
+});
+export const listExtensions = defineTool({
+    name: 'list_extensions',
+    description: 'Lists all extensions via this server, including their name, ID, version, and enabled status.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: true,
+        conditions: [EXTENSIONS_CONDITION],
+    },
+    schema: {},
+    handler: async (_request, response, _context) => {
+        response.setListExtensions();
+    },
+});
+export const reloadExtension = defineTool({
+    name: 'reload_extension',
+    description: 'Reloads an unpacked Chrome extension by its ID.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: false,
+        conditions: [EXTENSIONS_CONDITION],
+    },
+    schema: {
+        id: zod.string().describe('ID of the extension to reload.'),
+    },
+    handler: async (request, response, context) => {
+        const { id } = request.params;
+        const extension = context.getExtension(id);
+        if (!extension) {
+            throw new Error(`Extension with ID ${id} not found.`);
+        }
+        await context.installExtension(extension.path);
+        response.appendResponseLine('Extension reloaded.');
+    },
+});

package/build/src/tools/input.js

@@ -103,11 +103,16 @@ async function selectOption(handle, aXNode, value) {
         throw new Error(`Could not find option with text "${value}"`);
     }
 }
+function hasOptionChildren(aXNode) {
+    return aXNode.children.some(child => child.role === 'option');
+}
 async function fillFormElement(uid, value, context) {
     const handle = await context.getElementByUid(uid);
     try {
         const aXNode = context.getAXNodeByUid(uid);
-        if (aXNode && aXNode.role === 'combobox') {
+        // We assume that combobox needs to be handled as select if it has
+        // role='combobox' and option children.
+        if (aXNode && aXNode.role === 'combobox' && hasOptionChildren(aXNode)) {
             await selectOption(handle, aXNode, value);
         }
         else {

package/build/src/tools/pages.js

@@ -185,7 +185,6 @@ export const resizePage = defineTool({
     },
     handler: async (request, response, context) => {
         const page = context.getSelectedPage();
-        // @ts-expect-error internal API for now.
         await page.resize({
             contentWidth: request.params.width,
             contentHeight: request.params.height,

package/build/src/tools/tools.js

@@ -3,8 +3,10 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import * as browserTools from './browser.js';
 import * as consoleTools from './console.js';
 import * as emulationTools from './emulation.js';
+import * as extensionTools from './extension.js';
 import * as inputTools from './input.js';
 import * as networkTools from './network.js';
 import * as pagesTools from './pages.js';
@@ -14,8 +16,10 @@ import * as scriptTools from './script.js';
 import * as snapshotTools from './snapshot.js';
 import * as webmcpTools from './webmcp.js';
 const tools = [
+    ...Object.values(browserTools),
     ...Object.values(consoleTools),
     ...Object.values(emulationTools),
+    ...Object.values(extensionTools),
     ...Object.values(inputTools),
     ...Object.values(networkTools),
     ...Object.values(pagesTools),

package/build/src/transports/WebMCPBridgeScript.js

@@ -100,6 +100,15 @@ export const WEB_MCP_BRIDGE_SCRIPT = `
     return false;
   }
 
+  function getTargetOrigin() {
+    var origin = window.location && typeof window.location.origin === 'string'
+      ? window.location.origin
+      : '';
+    // about:blank, file://, and sandboxed contexts expose "null" origin.
+    // Use "*" so postMessage remains functional in those contexts.
+    return origin && origin !== 'null' ? origin : '*';
+  }
+
   // Initial check
   checkWebMCPAvailable();
 
@@ -125,7 +134,7 @@ export const WEB_MCP_BRIDGE_SCRIPT = `
           type: 'mcp',
           direction: 'client-to-server',
           payload: payload
-        }, window.location.origin);
+        }, getTargetOrigin());
 
         return true;
       } catch (err) {
@@ -169,7 +178,7 @@ export const WEB_MCP_BRIDGE_SCRIPT = `
         type: 'mcp',
         direction: 'client-to-server',
         payload: 'mcp-check-ready'
-      }, window.location.origin);
+      }, getTargetOrigin());
     },
 
     /**

package/build/src/utils/ExtensionRegistry.js

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export class ExtensionRegistry {
+    #extensions = new Map();
+    async registerExtension(id, extensionPath) {
+        const manifestPath = path.join(extensionPath, 'manifest.json');
+        const manifestContent = await fs.readFile(manifestPath, 'utf-8');
+        const manifest = JSON.parse(manifestContent);
+        const name = manifest.name ?? 'Unknown';
+        const version = manifest.version ?? 'Unknown';
+        const extension = {
+            id,
+            name,
+            version,
+            isEnabled: true,
+            path: extensionPath,
+        };
+        this.#extensions.set(extension.id, extension);
+        return extension;
+    }
+    remove(id) {
+        this.#extensions.delete(id);
+    }
+    list() {
+        return Array.from(this.#extensions.values());
+    }
+    getById(id) {
+        return this.#extensions.get(id);
+    }
+}

package/build/src/utils/string.js

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Converts a given string to snake_case.
+ * This function handles camelCase, PascalCase, and acronyms, including transitions between letters and numbers.
+ * It uses Unicode-aware regular expressions (`\p{L}`, `\p{N}`, `\p{Lu}`, `\p{Ll}` with the `u` flag)
+ * to correctly process letters and numbers from various languages.
+ *
+ * @param text The input string to convert to snake_case.
+ * @returns The snake_case version of the input string.
+ */
+export function toSnakeCase(text) {
+    if (!text) {
+        return '';
+    }
+    // First, handle case-based transformations to insert underscores correctly.
+    // 1. Add underscore between a letter and a number.
+    //    e.g., "version2" -> "version_2"
+    // 2. Add underscore between an uppercase letter sequence and a following uppercase+lowercase sequence.
+    //    e.g., "APIFlags" -> "API_Flags"
+    // 3. Add underscore between a lowercase/number and an uppercase letter.
+    //    e.g., "lastName" -> "last_Name", "version_2Update" -> "version_2_Update"
+    // 4. Replace sequences of non-alphanumeric with a single underscore
+    // 5. Remove any leading or trailing underscores.
+    const result = text
+        .replace(/(\p{L})(\p{N})/gu, '$1_$2') // 1
+        .replace(/(\p{Lu}+)(\p{Lu}\p{Ll})/gu, '$1_$2') // 2
+        .replace(/(\p{Ll}|\p{N})(\p{Lu})/gu, '$1_$2') // 3
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, '_') // 4
+        .replace(/^_|_$/g, ''); // 5
+    return result;
+}

package/build/vendor/chrome-devtools-frontend/front_end/core/common/Base64.js

@@ -29,13 +29,31 @@ export function decode(input) {
     }
     return bytes;
 }
+/**
+ * Note: if input can be very large (larger than the max string size), callers should
+ * expect this to throw an error.
+ */
 export function encode(input) {
     return new Promise((resolve, reject) => {
         const reader = new FileReader();
-        reader.onerror = () => reject(new Error('failed to convert to base64'));
+        reader.onerror = () => reject(new Error('failed to convert to base64: internal error'));
         reader.onload = () => {
+            // The input was too large to encode as a string. The caller should anticipate
+            // this and use a workaround. See TimelinePanel.ts innerSaveToFile for an example.
+            // For more information, see crbug.com/436482118.
+            if (reader.result === '') {
+                reject(new Error('failed to convert to base64: input too large to encode as base64 string'));
+                return;
+            }
+            // This string can be very large, so take care to not double memory. `split`
+            // was used here before, which always results in new strings in V8. By using
+            // slice instead, we leverage the sliced string optimization in V8 and avoid
+            // doubling the memory requirement (even if temporarily: that is a potential
+            // source of OOM crashes given large enough input, such as is common with
+            // Performance traces).
             const blobAsUrl = reader.result;
-            const [, base64] = blobAsUrl.split(',', 2);
+            const index = blobAsUrl.indexOf(',');
+            const base64 = blobAsUrl.slice(index + 1);
             resolve(base64);
         };
         reader.readAsDataURL(new Blob([input]));

package/build/vendor/chrome-devtools-frontend/front_end/core/common/Debouncer.js

@@ -8,7 +8,14 @@ export const debounce = function (func, delay) {
     let timer;
     const debounced = (...args) => {
         clearTimeout(timer);
-        timer = setTimeout(() => func(...args), delay);
+        timer = setTimeout(() => func(...args), testDebounceOverride ? 0 : delay);
     };
     return debounced;
 };
+let testDebounceOverride = false;
+export function enableTestOverride() {
+    testDebounceOverride = true;
+}
+export function disableTestOverride() {
+    testDebounceOverride = false;
+}

package/build/vendor/chrome-devtools-frontend/front_end/core/common/Gzip.js

@@ -64,3 +64,14 @@ export function compressStream(stream) {
     const cs = new CompressionStream('gzip');
     return stream.pipeThrough(cs);
 }
+export function createMonitoredStream(stream, onProgress) {
+    let bytesRead = 0;
+    const progressTransformer = new TransformStream({
+        transform(chunk, controller) {
+            bytesRead += chunk.byteLength;
+            onProgress(bytesRead);
+            controller.enqueue(chunk);
+        }
+    });
+    return stream.pipeThrough(progressTransformer);
+}

package/build/vendor/chrome-devtools-frontend/front_end/core/common/Object.js

@@ -57,7 +57,12 @@ export class ObjectWrapper {
         // new listeners.
         for (const listener of [...listeners]) {
             if (!listener.disposed) {
-                listener.listener.call(listener.thisObject, event);
+                try {
+                    listener.listener.call(listener.thisObject, event);
+                }
+                catch (err) {
+                    console.error(`Event listener for ${String(eventType)} throw an error:`, err);
+                }
             }
         }
     }

package/build/vendor/chrome-devtools-frontend/front_end/core/common/ParsedURL.js

@@ -263,6 +263,9 @@ export class ParsedURL {
         return '';
     }
     static extractName(url) {
+        if (url.endsWith('/')) {
+            url = url.slice(0, -1);
+        }
         let index = url.lastIndexOf('/');
         const pathAndQuery = index !== -1 ? url.substr(index + 1) : url;
         index = pathAndQuery.indexOf('?');

package/build/vendor/chrome-devtools-frontend/front_end/core/common/ResourceType.js

@@ -229,6 +229,12 @@ export class ResourceType {
         const regex = new RegExp('^application(.*json$|\/json\+.*)');
         return regex.test(contentType) ? 'application/json' : contentType;
     }
+    /**
+     * Checks whether the given MIME type represents JavaScript content.
+     */
+    static isJavaScriptMimeType(mimeType) {
+        return mimeType === 'application/javascript' || mimeType === 'text/javascript';
+    }
     /**
      * Adds suffixes iff the mimeType is 'text/javascript' to denote whether the JS is minified or from
      * a source map.