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

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/StringUtilities.js

@@ -233,7 +233,7 @@ export const stripLineBreaks = (inputStr) => {
 };
 const EXTENDED_KEBAB_CASE_REGEXP = /^([a-z0-9]+(?:-[a-z0-9]+)*\.)*[a-z0-9]+(?:-[a-z0-9]+)*$/;
 /**
- * Tests if the `inputStr` is following the extended Kebab Case naming convetion,
+ * Tests if the `inputStr` is following the extended Kebab Case naming convention,
  * where words are separated with either a dash (`-`) or a dot (`.`), and all
  * characters must be lower-case alphanumeric.
  *
@@ -351,7 +351,7 @@ export const escapeForRegExp = (str) => {
 };
 export const naturalOrderComparator = (a, b) => {
     const chunk = /^\d+|^\D+/;
-    let chunka, chunkb, anum, bnum;
+    let chunkA, chunkB, numA, numB;
     while (true) {
         if (a) {
             if (!b) {
@@ -364,33 +364,33 @@ export const naturalOrderComparator = (a, b) => {
             }
             return 0;
         }
-        chunka = a.match(chunk)[0];
-        chunkb = b.match(chunk)[0];
-        anum = !Number.isNaN(Number(chunka));
-        bnum = !Number.isNaN(Number(chunkb));
-        if (anum && !bnum) {
+        chunkA = a.match(chunk)[0];
+        chunkB = b.match(chunk)[0];
+        numA = !Number.isNaN(Number(chunkA));
+        numB = !Number.isNaN(Number(chunkB));
+        if (numA && !numB) {
             return -1;
         }
-        if (bnum && !anum) {
+        if (numB && !numA) {
             return 1;
         }
-        if (anum && bnum) {
-            const diff = Number(chunka) - Number(chunkb);
+        if (numA && numB) {
+            const diff = Number(chunkA) - Number(chunkB);
             if (diff) {
                 return diff;
             }
-            if (chunka.length !== chunkb.length) {
-                if (!Number(chunka) && !Number(chunkb)) { // chunks are strings of all 0s (special case)
-                    return chunka.length - chunkb.length;
+            if (chunkA.length !== chunkB.length) {
+                if (!Number(chunkA) && !Number(chunkB)) { // chunks are strings of all 0s (special case)
+                    return chunkA.length - chunkB.length;
                 }
-                return chunkb.length - chunka.length;
+                return chunkB.length - chunkA.length;
             }
         }
-        else if (chunka !== chunkb) {
-            return (chunka < chunkb) ? -1 : 1;
+        else if (chunkA !== chunkB) {
+            return (chunkA < chunkB) ? -1 : 1;
         }
-        a = a.substring(chunka.length);
-        b = b.substring(chunkb.length);
+        a = a.substring(chunkA.length);
+        b = b.substring(chunkB.length);
     }
 };
 export const base64ToSize = function (content) {
@@ -458,19 +458,21 @@ export const createPlainTextSearchRegex = function (query, flags) {
 export const toLowerCaseString = function (input) {
     return input.toLowerCase();
 };
+/**
+ * 1: two or more consecutive uppercase letters. This is useful for identifying acronyms
+ * 2: lookahead assertion that matches a word boundary
+ * 3: numeronym: single letter followed by number and another letter
+ * 4: word starting with an optional uppercase letter
+ * 5: single digit followed by word to handle '3D' or '2px' (this might be controverial)
+ * 6: single uppercase letter or number
+ * 7: a dot character. We extract it into a separate word and remove dashes around it later.
+ * This is makes more sense conceptually and allows accounting for all possible word variants.
+ * Making dot a part of a word prevent us from handling acronyms or numeronyms after the word
+ * correctly without making the RegExp prohibitively complicated.
+ * https://regex101.com/r/FhMVKc/1
+ *            <---1---><------------2-----------> <---------3--------> <-----4----> <------5-----> <-----6----> <7>
+ */
 const WORD = /[A-Z]{2,}(?=[A-Z0-9][a-z0-9]+|\b|_)|[A-Za-z][0-9]+[a-z]?|[A-Z]?[a-z]+|[0-9][A-Za-z]+|[A-Z]|[0-9]+|[.]/g;
-//            <---1---><------------2-----------> <---------3--------> <-----4----> <------5-----> <-----6----> <7>
-// 1: two or more consecutive uppercase letters. This is useful for identifying acronyms
-// 2: lookahead assertion that matches a word boundary
-// 3: numeronym: single letter followed by number and another letter
-// 4: word starting with an optional uppercase letter
-// 5: single digit followed by word to handle '3D' or '2px' (this might be controverial)
-// 6: single uppercase letter or number
-// 7: a dot character. We extract it into a separate word and remove dashes around it later.
-//    This is makes more sense conceptually and allows accounting for all possible word variants.
-//    Making dot a part of a word prevent us from handling acronyms or numeronyms after the word
-//    correctly without making the RegExp prohibitively complicated.
-// https://regex101.com/r/FhMVKc/1
 export const toKebabCase = function (input) {
     return (input.match?.(WORD)?.map(w => w.toLowerCase()).join('-').replaceAll('-.-', '.') || input);
 };
@@ -507,7 +509,7 @@ export function toSnakeCase(text) {
         .replace(/^_|_$/g, ''); // 5
     return result;
 }
-// Replaces the last ocurrence of parameter `search` with parameter `replacement` in `input`
+/** Replaces the last occurrence of parameter `search` with parameter `replacement` in `input` **/
 export const replaceLast = function (input, search, replacement) {
     const replacementStartIndex = input.lastIndexOf(search);
     if (replacementStartIndex === -1) {
@@ -532,5 +534,5 @@ export const concatBase64 = function (lhs, rhs) {
     }
     const lhsLeaveAsIs = lhs.substring(0, lhs.length - 4);
     const lhsToDecode = lhs.substring(lhs.length - 4);
-    return lhsLeaveAsIs + window.btoa(window.atob(lhsToDecode) + window.atob(rhs));
+    return lhsLeaveAsIs + globalThis.btoa(globalThis.atob(lhsToDecode) + globalThis.atob(rhs));
 };

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/api/HostRuntime.js

@@ -0,0 +1,4 @@
+// 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.
+export {};

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/api/api.js

@@ -0,0 +1,5 @@
+// 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 * as HostRuntime from './HostRuntime.js';
+export { HostRuntime };

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/browser/HostRuntime.js

@@ -0,0 +1,63 @@
+// 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.
+class WebWorkerScope {
+    postMessage(message) {
+        self.postMessage(message);
+    }
+    set onmessage(listener) {
+        self.onmessage = listener;
+    }
+}
+class WebWorker {
+    #workerPromise;
+    #disposed;
+    #rejectWorkerPromise;
+    constructor(workerLocation) {
+        this.#workerPromise = new Promise((fulfill, reject) => {
+            this.#rejectWorkerPromise = reject;
+            const worker = new Worker(new URL(workerLocation), { type: 'module' });
+            worker.onerror = event => {
+                console.error(`Failed to load worker for ${workerLocation}:`, event);
+            };
+            worker.onmessage = (event) => {
+                console.assert(event.data === 'workerReady');
+                worker.onmessage = null;
+                fulfill(worker);
+            };
+        });
+    }
+    postMessage(message, transfer) {
+        void this.#workerPromise.then(worker => {
+            if (!this.#disposed) {
+                worker.postMessage(message, transfer ?? []);
+            }
+        });
+    }
+    dispose() {
+        this.#disposed = true;
+        void this.#workerPromise.then(worker => worker.terminate());
+    }
+    terminate(immediately = false) {
+        if (immediately) {
+            this.#rejectWorkerPromise?.(new Error('Worker terminated'));
+        }
+        this.dispose();
+    }
+    set onmessage(listener) {
+        void this.#workerPromise.then(worker => {
+            worker.onmessage = listener;
+        });
+    }
+    set onerror(listener) {
+        void this.#workerPromise.then(worker => {
+            worker.onerror = listener;
+        });
+    }
+}
+export const HOST_RUNTIME = {
+    createWorker(url) {
+        return new WebWorker(url);
+    },
+    workerScope: new WebWorkerScope(),
+};

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/browser/browser.js

@@ -0,0 +1,5 @@
+// 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 * as HostRuntime from './HostRuntime.js';
+export { HostRuntime };

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/node/HostRuntime.js

@@ -0,0 +1,72 @@
+// 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 * as WorkerThreads from 'node:worker_threads';
+class NodeWorkerScope {
+    postMessage(message) {
+        WorkerThreads.parentPort?.postMessage(message);
+    }
+    set onmessage(listener) {
+        WorkerThreads.parentPort?.on('message', data => {
+            listener({ data });
+        });
+    }
+}
+class NodeWorker {
+    #workerPromise;
+    #disposed = false;
+    #rejectWorkerPromise;
+    constructor(url) {
+        this.#workerPromise = new Promise((resolve, reject) => {
+            this.#rejectWorkerPromise = reject;
+            const worker = new WorkerThreads.Worker(new URL(url));
+            worker.once('message', (message) => {
+                if (message === 'workerReady') {
+                    resolve(worker);
+                }
+            });
+            worker.on('error', reject);
+        });
+    }
+    postMessage(message) {
+        void this.#workerPromise.then(worker => {
+            if (!this.#disposed) {
+                worker.postMessage(message);
+            }
+        });
+    }
+    dispose() {
+        this.#disposed = true;
+        void this.#workerPromise.then(worker => worker.terminate());
+    }
+    terminate(immediately) {
+        if (immediately) {
+            this.#rejectWorkerPromise?.(new Error('Worker terminated'));
+        }
+        this.dispose();
+    }
+    set onmessage(listener) {
+        void this.#workerPromise.then(worker => {
+            worker.on('message', data => {
+                if (!this.#disposed) {
+                    listener({ data });
+                }
+            });
+        });
+    }
+    set onerror(listener) {
+        void this.#workerPromise.then(worker => {
+            worker.on('error', (error) => {
+                if (!this.#disposed) {
+                    listener({ type: 'error', ...error });
+                }
+            });
+        });
+    }
+}
+export const HOST_RUNTIME = {
+    createWorker(url) {
+        return new NodeWorker(url);
+    },
+    workerScope: new NodeWorkerScope(),
+};

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/node/node.js

@@ -0,0 +1,5 @@
+// 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 * as HostRuntime from './HostRuntime.js';
+export { HostRuntime };

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

@@ -6,7 +6,7 @@ import * as Brand from './Brand.js';
 import * as Constructor from './Constructor.js';
 import * as DateUtilities from './DateUtilities.js';
 import * as DevToolsPath from './DevToolsPath.js';
-import * as DOMUtilities from './DOMUtilities.js';
+import * as HostRuntime from './HostRuntime.js';
 import * as KeyboardUtilities from './KeyboardUtilities.js';
 import * as MapUtilities from './MapUtilities.js';
 import * as MimeType from './MimeType.js';
@@ -23,4 +23,4 @@ import * as UserVisibleError from './UserVisibleError.js';
  * error).
  */
 export { assertNever, assertNotNullOrUndefined, assertUnhandled } from './TypescriptUtilities.js';
-export { ArrayUtilities, Brand, Constructor, DateUtilities, DevToolsPath, DOMUtilities, KeyboardUtilities, MapUtilities, MimeType, NumberUtilities, StringUtilities, Timing, TypedArrayUtilities, TypeScriptUtilities, UIString, UserVisibleError, };
+export { ArrayUtilities, Brand, Constructor, DateUtilities, DevToolsPath, HostRuntime, KeyboardUtilities, MapUtilities, MimeType, NumberUtilities, StringUtilities, Timing, TypedArrayUtilities, TypeScriptUtilities, UIString, UserVisibleError, };

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/CDPConnection.js

@@ -0,0 +1,17 @@
+// 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.
+/**
+ * Keep this in sync with https://source.chromium.org/chromium/chromium/src/+/main:third_party/inspector_protocol/crdtp/dispatch.h.
+ */
+export var CDPErrorStatus;
+(function (CDPErrorStatus) {
+    CDPErrorStatus[CDPErrorStatus["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+    CDPErrorStatus[CDPErrorStatus["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+    CDPErrorStatus[CDPErrorStatus["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+    CDPErrorStatus[CDPErrorStatus["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+    CDPErrorStatus[CDPErrorStatus["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+    CDPErrorStatus[CDPErrorStatus["SERVER_ERROR"] = -32000] = "SERVER_ERROR";
+    CDPErrorStatus[CDPErrorStatus["SESSION_NOT_FOUND"] = -32001] = "SESSION_NOT_FOUND";
+    CDPErrorStatus[CDPErrorStatus["DEVTOOLS_STUB_ERROR"] = -32015] = "DEVTOOLS_STUB_ERROR";
+})(CDPErrorStatus || (CDPErrorStatus = {}));

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/ConnectionTransport.js

@@ -0,0 +1,12 @@
+// 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.
+let connectionFactory;
+export class ConnectionTransport {
+    static setFactory(factory) {
+        connectionFactory = factory;
+    }
+    static getFactory() {
+        return connectionFactory;
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/DevToolsCDPConnection.js

@@ -0,0 +1,138 @@
+// 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 { CDPErrorStatus } from './CDPConnection.js';
+import { InspectorBackend, test } from './InspectorBackend.js';
+const LongPollingMethods = new Set(['CSS.takeComputedStyleUpdates']);
+export class DevToolsCDPConnection {
+    #transport;
+    #lastMessageId = 1;
+    #pendingResponsesCount = 0;
+    #pendingLongPollingMessageIds = new Set();
+    #pendingScripts = [];
+    #callbacks = new Map();
+    #observers = new Set();
+    constructor(transport) {
+        this.#transport = transport;
+        test.deprecatedRunAfterPendingDispatches = this.deprecatedRunAfterPendingDispatches.bind(this);
+        test.sendRawMessage = this.sendRawMessageForTesting.bind(this);
+        this.#transport.setOnMessage(this.onMessage.bind(this));
+        this.#transport.setOnDisconnect(reason => {
+            this.#observers.forEach(observer => observer.onDisconnect(reason));
+        });
+    }
+    observe(observer) {
+        this.#observers.add(observer);
+    }
+    unobserve(observer) {
+        this.#observers.delete(observer);
+    }
+    send(method, params, sessionId) {
+        const messageId = ++this.#lastMessageId;
+        const messageObject = {
+            id: messageId,
+            method,
+        };
+        if (params) {
+            messageObject.params = params;
+        }
+        if (sessionId) {
+            messageObject.sessionId = sessionId;
+        }
+        if (test.dumpProtocol) {
+            test.dumpProtocol('frontend: ' + JSON.stringify(messageObject));
+        }
+        if (test.onMessageSent) {
+            const domain = method.split('.')[0];
+            const paramsObject = JSON.parse(JSON.stringify(params || {}));
+            test.onMessageSent({ domain, method, params: paramsObject, id: messageId, sessionId });
+        }
+        ++this.#pendingResponsesCount;
+        if (LongPollingMethods.has(method)) {
+            this.#pendingLongPollingMessageIds.add(messageId);
+        }
+        return new Promise(resolve => {
+            this.#callbacks.set(messageId, { resolve, method, sessionId });
+            this.#transport.sendRawMessage(JSON.stringify(messageObject));
+        });
+    }
+    resolvePendingCalls(sessionId) {
+        for (const { resolve, method, sessionId: callbackSessionId } of this.#callbacks.values()) {
+            if (sessionId !== callbackSessionId) {
+                continue;
+            }
+            resolve({
+                error: {
+                    message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
+                    code: CDPErrorStatus.SESSION_NOT_FOUND,
+                }
+            });
+        }
+    }
+    sendRawMessageForTesting(method, params, callback, sessionId = '') {
+        void this.send(method, params, sessionId).then(response => {
+            if ('error' in response && response.error) {
+                callback?.(response.error, null);
+            }
+            else if ('result' in response) {
+                callback?.(null, response.result);
+            }
+        });
+    }
+    onMessage(message) {
+        if (test.dumpProtocol) {
+            test.dumpProtocol('backend: ' + ((typeof message === 'string') ? message : JSON.stringify(message)));
+        }
+        if (test.onMessageReceived) {
+            const messageObjectCopy = JSON.parse((typeof message === 'string') ? message : JSON.stringify(message));
+            test.onMessageReceived(messageObjectCopy);
+        }
+        const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message);
+        if ('id' in messageObject && messageObject.id !== undefined) { // just a response for some request
+            const callback = this.#callbacks.get(messageObject.id);
+            this.#callbacks.delete(messageObject.id);
+            if (!callback) {
+                // Ignore messages with unknown IDs, we might see puppeteer proxied messages here.
+                return;
+            }
+            callback.resolve(messageObject);
+            --this.#pendingResponsesCount;
+            this.#pendingLongPollingMessageIds.delete(messageObject.id);
+            if (this.#pendingScripts.length && !this.hasOutstandingNonLongPollingRequests()) {
+                this.deprecatedRunAfterPendingDispatches();
+            }
+        }
+        else if ('method' in messageObject) {
+            this.#observers.forEach(observer => observer.onEvent(messageObject));
+        }
+        else {
+            InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
+        }
+    }
+    hasOutstandingNonLongPollingRequests() {
+        return this.#pendingResponsesCount - this.#pendingLongPollingMessageIds.size > 0;
+    }
+    deprecatedRunAfterPendingDispatches(script) {
+        if (script) {
+            this.#pendingScripts.push(script);
+        }
+        // Execute all promises.
+        setTimeout(() => {
+            if (!this.hasOutstandingNonLongPollingRequests()) {
+                this.executeAfterPendingDispatches();
+            }
+            else {
+                this.deprecatedRunAfterPendingDispatches();
+            }
+        }, 0);
+    }
+    executeAfterPendingDispatches() {
+        if (!this.hasOutstandingNonLongPollingRequests()) {
+            const scripts = this.#pendingScripts;
+            this.#pendingScripts = [];
+            for (let id = 0; id < scripts.length; ++id) {
+                scripts[id]();
+            }
+        }
+    }
+}