@mcp-b/chrome-devtools-mcp 2.3.0 → 2.3.1-beta.20260528050333

package/build/src/Mutex.js

@@ -1,37 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-export class Mutex {
-    static Guard = class Guard {
-        #mutex;
-        constructor(mutex) {
-            this.#mutex = mutex;
-        }
-        dispose() {
-            return this.#mutex.release();
-        }
-    };
-    #locked = false;
-    #acquirers = [];
-    // This is FIFO.
-    async acquire() {
-        if (!this.#locked) {
-            this.#locked = true;
-            return new Mutex.Guard(this);
-        }
-        const { resolve, promise } = Promise.withResolvers();
-        this.#acquirers.push(resolve);
-        await promise;
-        return new Mutex.Guard(this);
-    }
-    release() {
-        const resolve = this.#acquirers.shift();
-        if (!resolve) {
-            this.#locked = false;
-            return;
-        }
-        resolve();
-    }
-}

package/build/src/PageCollector.js

@@ -1,308 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { FakeIssuesManager } from './DevtoolsUtils.js';
-import { logger } from './logger.js';
-import { DevTools } from './third_party/index.js';
-export class UncaughtError {
-    details;
-    targetId;
-    constructor(details, targetId) {
-        this.details = details;
-        this.targetId = targetId;
-    }
-}
-function createIdGenerator() {
-    let i = 1;
-    return () => {
-        if (i === Number.MAX_SAFE_INTEGER) {
-            i = 0;
-        }
-        return i++;
-    };
-}
-export const stableIdSymbol = Symbol('stableIdSymbol');
-export class PageCollector {
-    #browser;
-    #listenersInitializer;
-    #listeners = new WeakMap();
-    maxNavigationSaved = 3;
-    /**
-     * This maps a Page to a list of navigations with a sub-list
-     * of all collected resources.
-     * The newer navigations come first.
-     */
-    storage = new WeakMap();
-    constructor(browser, listeners) {
-        this.#browser = browser;
-        this.#listenersInitializer = listeners;
-    }
-    async init(pages) {
-        for (const page of pages) {
-            this.addPage(page);
-        }
-        this.#browser.on('targetcreated', this.#onTargetCreated);
-        this.#browser.on('targetdestroyed', this.#onTargetDestroyed);
-    }
-    dispose() {
-        this.#browser.off('targetcreated', this.#onTargetCreated);
-        this.#browser.off('targetdestroyed', this.#onTargetDestroyed);
-    }
-    #onTargetCreated = async (target) => {
-        try {
-            const page = await target.page();
-            if (!page) {
-                return;
-            }
-            this.addPage(page);
-        }
-        catch (err) {
-            logger('Error getting a page for a target onTargetCreated', err);
-        }
-    };
-    #onTargetDestroyed = async (target) => {
-        try {
-            const page = await target.page();
-            if (!page) {
-                return;
-            }
-            this.cleanupPageDestroyed(page);
-        }
-        catch (err) {
-            logger('Error getting a page for a target onTargetDestroyed', err);
-        }
-    };
-    addPage(page) {
-        this.#initializePage(page);
-    }
-    #initializePage(page) {
-        if (this.storage.has(page)) {
-            return;
-        }
-        const idGenerator = createIdGenerator();
-        const storedLists = [[]];
-        this.storage.set(page, storedLists);
-        const listeners = this.#listenersInitializer((value) => {
-            const withId = value;
-            withId[stableIdSymbol] = idGenerator();
-            const navigations = this.storage.get(page) ?? [[]];
-            navigations[0].push(withId);
-        });
-        listeners['framenavigated'] = (frame) => {
-            // Only split the storage on main frame navigation
-            if (frame !== page.mainFrame()) {
-                return;
-            }
-            this.splitAfterNavigation(page);
-        };
-        for (const [name, listener] of Object.entries(listeners)) {
-            page.on(name, listener);
-        }
-        this.#listeners.set(page, listeners);
-    }
-    splitAfterNavigation(page) {
-        const navigations = this.storage.get(page);
-        if (!navigations) {
-            return;
-        }
-        // Add the latest navigation first
-        navigations.unshift([]);
-        navigations.splice(this.maxNavigationSaved);
-    }
-    cleanupPageDestroyed(page) {
-        const listeners = this.#listeners.get(page);
-        if (listeners) {
-            for (const [name, listener] of Object.entries(listeners)) {
-                page.off(name, listener);
-            }
-        }
-        this.storage.delete(page);
-    }
-    getData(page, includePreservedData) {
-        const navigations = this.storage.get(page);
-        if (!navigations) {
-            return [];
-        }
-        if (!includePreservedData) {
-            return navigations[0];
-        }
-        const data = [];
-        for (let index = this.maxNavigationSaved; index >= 0; index--) {
-            if (navigations[index]) {
-                data.push(...navigations[index]);
-            }
-        }
-        return data;
-    }
-    getIdForResource(resource) {
-        return resource[stableIdSymbol] ?? -1;
-    }
-    getById(page, stableId) {
-        const navigations = this.storage.get(page);
-        if (!navigations) {
-            throw new Error('No requests found for selected page');
-        }
-        const item = this.find(page, (item) => item[stableIdSymbol] === stableId);
-        if (item) {
-            return item;
-        }
-        throw new Error('Request not found for selected page');
-    }
-    find(page, filter) {
-        const navigations = this.storage.get(page);
-        if (!navigations) {
-            return;
-        }
-        for (const navigation of navigations) {
-            const item = navigation.find(filter);
-            if (item) {
-                return item;
-            }
-        }
-        return;
-    }
-}
-export class ConsoleCollector extends PageCollector {
-    #subscribedPages = new WeakMap();
-    addPage(page) {
-        super.addPage(page);
-        if (!this.#subscribedPages.has(page)) {
-            const subscriber = new PageEventSubscriber(page);
-            this.#subscribedPages.set(page, subscriber);
-            void subscriber.subscribe();
-        }
-    }
-    cleanupPageDestroyed(page) {
-        super.cleanupPageDestroyed(page);
-        this.#subscribedPages.get(page)?.unsubscribe();
-        this.#subscribedPages.delete(page);
-    }
-}
-class PageEventSubscriber {
-    #issueManager = new FakeIssuesManager();
-    #issueAggregator = new DevTools.IssueAggregator(this.#issueManager);
-    #seenKeys = new Set();
-    #seenIssues = new Set();
-    #page;
-    #session;
-    #targetId;
-    constructor(page) {
-        this.#page = page;
-        // @ts-expect-error use existing CDP client (internal Puppeteer API).
-        this.#session = this.#page._client();
-        // @ts-expect-error use internal Puppeteer API to get target ID
-        this.#targetId = this.#session.target()._targetId;
-    }
-    #resetIssueAggregator() {
-        this.#issueManager = new FakeIssuesManager();
-        if (this.#issueAggregator) {
-            this.#issueAggregator.removeEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedissue);
-        }
-        this.#issueAggregator = new DevTools.IssueAggregator(this.#issueManager);
-        this.#issueAggregator.addEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedissue);
-    }
-    async subscribe() {
-        this.#resetIssueAggregator();
-        this.#page.on('framenavigated', this.#onFrameNavigated);
-        this.#session.on('Audits.issueAdded', this.#onIssueAdded);
-        this.#session.on('Runtime.exceptionThrown', this.#onExceptionThrown);
-        try {
-            await this.#session.send('Audits.enable');
-        }
-        catch (error) {
-            logger('Error subscribing to issues', error);
-        }
-    }
-    unsubscribe() {
-        this.#seenKeys.clear();
-        this.#seenIssues.clear();
-        this.#page.off('framenavigated', this.#onFrameNavigated);
-        this.#session.off('Audits.issueAdded', this.#onIssueAdded);
-        this.#session.off('Runtime.exceptionThrown', this.#onExceptionThrown);
-        if (this.#issueAggregator) {
-            this.#issueAggregator.removeEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedissue);
-        }
-        void this.#session.send('Audits.disable').catch(() => {
-            // might fail.
-        });
-    }
-    #onAggregatedissue = (event) => {
-        if (this.#seenIssues.has(event.data)) {
-            return;
-        }
-        this.#seenIssues.add(event.data);
-        this.#page.emit('issue', event.data);
-    };
-    #onExceptionThrown = (event) => {
-        this.#page.emit('uncaughtError', new UncaughtError(event.exceptionDetails, this.#targetId));
-    };
-    // On navigation, we reset issue aggregation.
-    #onFrameNavigated = (frame) => {
-        // Only split the storage on main frame navigation
-        if (frame !== frame.page().mainFrame()) {
-            return;
-        }
-        this.#seenKeys.clear();
-        this.#seenIssues.clear();
-        this.#resetIssueAggregator();
-    };
-    #onIssueAdded = (data) => {
-        try {
-            const inspectorIssue = data.issue;
-            const issue = DevTools.createIssuesFromProtocolIssue(null, 
-            // @ts-expect-error Protocol types diverge.
-            inspectorIssue)[0];
-            if (!issue) {
-                logger('No issue mapping for for the issue: ', inspectorIssue.code);
-                return;
-            }
-            const primaryKey = issue.primaryKey();
-            if (this.#seenKeys.has(primaryKey)) {
-                return;
-            }
-            this.#seenKeys.add(primaryKey);
-            this.#issueManager.dispatchEventToListeners("IssueAdded" /* DevTools.IssuesManagerEvents.ISSUE_ADDED */, {
-                issue,
-                // @ts-expect-error We don't care that issues model is null
-                issuesModel: null,
-            });
-        }
-        catch (error) {
-            logger('Error creating a new issue', error);
-        }
-    };
-}
-export class NetworkCollector extends PageCollector {
-    constructor(browser, listeners = (collect) => {
-        return {
-            request: (req) => {
-                collect(req);
-            },
-        };
-    }) {
-        super(browser, listeners);
-    }
-    splitAfterNavigation(page) {
-        const navigations = this.storage.get(page) ?? [];
-        if (!navigations) {
-            return;
-        }
-        const requests = navigations[0];
-        const lastRequestIdx = requests.findLastIndex((request) => {
-            return request.frame() === page.mainFrame() ? request.isNavigationRequest() : false;
-        });
-        // Keep all requests since the last navigation request including that
-        // navigation request itself.
-        // Keep the reference
-        if (lastRequestIdx !== -1) {
-            const fromCurrentNavigation = requests.splice(lastRequestIdx);
-            navigations.unshift(fromCurrentNavigation);
-        }
-        else {
-            navigations.unshift([]);
-        }
-        navigations.splice(this.maxNavigationSaved);
-    }
-}

package/build/src/SlimMcpResponse.js

@@ -1,18 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { McpResponse } from './McpResponse.js';
-export class SlimMcpResponse extends McpResponse {
-    async handle(_toolName, _context) {
-        const text = {
-            type: 'text',
-            text: this.responseLines.join('\n'),
-        };
-        return {
-            content: [text],
-            structuredContent: text,
-        };
-    }
-}

package/build/src/WaitForHelper.js

@@ -1,135 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { logger } from './logger.js';
-export class WaitForHelper {
-    #abortController = new AbortController();
-    #page;
-    #stableDomTimeout;
-    #stableDomFor;
-    #expectNavigationIn;
-    #navigationTimeout;
-    constructor(page, cpuTimeoutMultiplier, networkTimeoutMultiplier) {
-        this.#stableDomTimeout = 3000 * cpuTimeoutMultiplier;
-        this.#stableDomFor = 100 * cpuTimeoutMultiplier;
-        this.#expectNavigationIn = 100 * cpuTimeoutMultiplier;
-        this.#navigationTimeout = 3000 * networkTimeoutMultiplier;
-        this.#page = page;
-    }
-    /**
-     * A wrapper that executes a action and waits for
-     * a potential navigation, after which it waits
-     * for the DOM to be stable before returning.
-     */
-    async waitForStableDom() {
-        const stableDomObserver = await this.#page.evaluateHandle((timeout) => {
-            let timeoutId;
-            function callback() {
-                clearTimeout(timeoutId);
-                timeoutId = setTimeout(() => {
-                    domObserver.resolver.resolve();
-                    domObserver.observer.disconnect();
-                }, timeout);
-            }
-            const domObserver = {
-                resolver: Promise.withResolvers(),
-                observer: new MutationObserver(callback),
-            };
-            // It's possible that the DOM is not gonna change so we
-            // need to start the timeout initially.
-            callback();
-            domObserver.observer.observe(document.body, {
-                childList: true,
-                subtree: true,
-                attributes: true,
-            });
-            return domObserver;
-        }, this.#stableDomFor);
-        this.#abortController.signal.addEventListener('abort', async () => {
-            try {
-                await stableDomObserver.evaluate((observer) => {
-                    observer.observer.disconnect();
-                    observer.resolver.resolve();
-                });
-                await stableDomObserver.dispose();
-            }
-            catch {
-                // Ignored cleanup errors
-            }
-        });
-        return Promise.race([
-            stableDomObserver.evaluate(async (observer) => {
-                return await observer.resolver.promise;
-            }),
-            this.timeout(this.#stableDomTimeout).then(() => {
-                throw new Error('Timeout');
-            }),
-        ]);
-    }
-    async waitForNavigationStarted() {
-        // Currently Puppeteer does not have API
-        // For when a navigation is about to start
-        const navigationStartedPromise = new Promise((resolve) => {
-            const listener = (event) => {
-                if (['historySameDocument', 'historyDifferentDocument', 'sameDocument'].includes(event.navigationType)) {
-                    resolve(false);
-                    return;
-                }
-                resolve(true);
-            };
-            this.#page._client().on('Page.frameStartedNavigating', listener);
-            this.#abortController.signal.addEventListener('abort', () => {
-                resolve(false);
-                this.#page._client().off('Page.frameStartedNavigating', listener);
-            });
-        });
-        return await Promise.race([
-            navigationStartedPromise,
-            this.timeout(this.#expectNavigationIn).then(() => false),
-        ]);
-    }
-    timeout(time) {
-        return new Promise((res) => {
-            const id = setTimeout(res, time);
-            this.#abortController.signal.addEventListener('abort', () => {
-                res();
-                clearTimeout(id);
-            });
-        });
-    }
-    async waitForEventsAfterAction(action, options) {
-        const navigationFinished = this.waitForNavigationStarted()
-            .then((navigationStated) => {
-            if (navigationStated) {
-                return this.#page.waitForNavigation({
-                    timeout: options?.timeout ?? this.#navigationTimeout,
-                    signal: this.#abortController.signal,
-                });
-            }
-            return;
-        })
-            .catch((error) => logger(error));
-        try {
-            await action();
-        }
-        catch (error) {
-            // Clear up pending promises
-            this.#abortController.abort();
-            throw error;
-        }
-        try {
-            await navigationFinished;
-            // Wait for stable dom after navigation so we execute in
-            // the correct context
-            await this.waitForStableDom();
-        }
-        catch (error) {
-            logger(error);
-        }
-        finally {
-            this.#abortController.abort();
-        }
-    }
-}