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

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

@@ -0,0 +1,24 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+/**
+ * This is useful to keep TypeScript happy in a test - if you have a value
+ * that's potentially `null` you can use this function to assert that it isn't,
+ * and satisfy TypeScript that the value is present.
+ */
+export function assertNotNullOrUndefined(val, message) {
+    if (val === null || val === undefined) {
+        throw new Error(`Expected given value to not be null/undefined but it was: ${val}${message ? `\n${message}` : ''}`);
+    }
+}
+export function assertNever(_type, message) {
+    throw new Error(message);
+}
+/**
+ * This is useful to check on the type-level that the unhandled cases of
+ * a switch are exactly `T` (where T is usually a union type of enum values).
+ * @param caseVariable
+ */
+export function assertUnhandled(_caseVariable) {
+    return _caseVariable;
+}

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

@@ -0,0 +1,4 @@
+// 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.
+export const LocalizedEmptyString = '';

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

@@ -0,0 +1,22 @@
+// 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.
+/**
+ * Represents an error that might become visible to the user. Where errors
+ * might be surfaced to the user (such as by displaying the message to the
+ * console), this class should be used to enforce that the message is
+ * localized on the way in.
+ */
+export class UserVisibleError extends Error {
+    message;
+    constructor(message) {
+        super(message);
+        this.message = message;
+    }
+}
+export function isUserVisibleError(error) {
+    if (typeof error === 'object' && error !== null) {
+        return error instanceof UserVisibleError;
+    }
+    return false;
+}

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

@@ -0,0 +1,26 @@
+// Copyright 2019 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 ArrayUtilities from './ArrayUtilities.js';
+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 HostRuntime from './HostRuntime.js';
+import * as KeyboardUtilities from './KeyboardUtilities.js';
+import * as MapUtilities from './MapUtilities.js';
+import * as MimeType from './MimeType.js';
+import * as NumberUtilities from './NumberUtilities.js';
+import * as StringUtilities from './StringUtilities.js';
+import * as Timing from './Timing.js';
+import * as TypedArrayUtilities from './TypedArrayUtilities.js';
+import * as TypeScriptUtilities from './TypescriptUtilities.js';
+import * as UIString from './UIString.js';
+import * as UserVisibleError from './UserVisibleError.js';
+/* `assertNotNullOrUndefined` also need to be exposed, as TypeScript does
+ * not allow `asserts` functions to be used with qualified access (e.g.
+ * `Platform.TypeScriptUtilities.assertNotNullOrUndefined` causes a compile
+ * error).
+ */
+export { assertNever, assertNotNullOrUndefined, assertUnhandled } from './TypescriptUtilities.js';
+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]();
+            }
+        }
+    }
+}