@nimbus21.ai/chrome-devtools-mcp 0.6.3 → 0.12.2

package/build/src/PageCollector.js

@@ -3,32 +3,69 @@
  * 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';
+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;
-    #initializer;
+    #listenersInitializer;
+    #listeners = new WeakMap();
+    #maxNavigationSaved = 3;
     /**
-     * The Array in this map should only be set once
-     * As we use the reference to it.
-     * Use methods that manipulate the array in place.
+     * 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, initializer) {
+    constructor(browser, listeners) {
         this.#browser = browser;
-        this.#initializer = initializer;
+        this.#listenersInitializer = listeners;
     }
-    async init() {
-        const pages = await this.#browser.pages();
+    async init(pages) {
         for (const page of pages) {
-            this.#initializePage(page);
+            this.addPage(page);
         }
-        this.#browser.on('targetcreated', async (target) => {
+        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.#initializePage(page);
-        });
-    }
+            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);
     }
@@ -36,36 +73,207 @@ export class PageCollector {
         if (this.storage.has(page)) {
             return;
         }
-        const stored = [];
-        this.storage.set(page, stored);
-        page.on('framenavigated', frame => {
-            // Only reset the storage on main frame navigation
+        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.cleanup(page);
-        });
-        this.#initializer(page, value => {
-            stored.push(value);
-        });
+            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);
     }
-    cleanup(page) {
-        const collection = this.storage.get(page);
-        if (collection) {
-            // Keep the reference alive
-            collection.length = 0;
+    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;
     }
-    getData(page) {
-        return this.storage.get(page) ?? [];
+    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 PageIssueSubscriber(page);
+            this.#subscribedPages.set(page, subscriber);
+            void subscriber.subscribe();
+        }
+    }
+    cleanupPageDestroyed(page) {
+        super.cleanupPageDestroyed(page);
+        this.#subscribedPages.get(page)?.unsubscribe();
+        this.#subscribedPages.delete(page);
     }
 }
+class PageIssueSubscriber {
+    #issueManager = new FakeIssuesManager();
+    #issueAggregator = new DevTools.IssueAggregator(this.#issueManager);
+    #seenKeys = new Set();
+    #seenIssues = new Set();
+    #page;
+    #session;
+    constructor(page) {
+        this.#page = page;
+        // @ts-expect-error use existing CDP client (internal Puppeteer API).
+        this.#session = this.#page._client();
+    }
+    #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);
+        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);
+        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);
+    };
+    // 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 {
-    cleanup(page) {
-        const requests = this.storage.get(page) ?? [];
-        if (!requests) {
+    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()
@@ -74,6 +282,12 @@ export class NetworkCollector extends PageCollector {
         // Keep all requests since the last navigation request including that
         // navigation request itself.
         // Keep the reference
-        requests.splice(0, Math.max(lastRequestIdx, 0));
+        if (lastRequestIdx !== -1) {
+            const fromCurrentNavigation = requests.splice(lastRequestIdx);
+            navigations.unshift(fromCurrentNavigation);
+        }
+        else {
+            navigations.unshift([]);
+        }
     }
 }

package/build/src/WaitForHelper.js

@@ -1,3 +1,8 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
 import { logger } from './logger.js';
 export class WaitForHelper {
     #abortController = new AbortController();

package/build/src/browser.js

@@ -6,47 +6,109 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import puppeteer from 'puppeteer-core';
 import puppeteerExtra from 'puppeteer-extra';
 import StealthPlugin from 'puppeteer-extra-plugin-stealth';
+import { logger } from './logger.js';
+import { puppeteer } from './third_party/index.js';
 // Add stealth plugin
 puppeteerExtra.use(StealthPlugin());
 let browser;
-const ignoredPrefixes = new Set([
-    'chrome://',
-    'chrome-extension://',
-    'chrome-untrusted://',
-    'devtools://',
-]);
-function targetFilter(target) {
-    if (target.url() === 'chrome://newtab/') {
-        return true;
-    }
-    for (const prefix of ignoredPrefixes) {
-        if (target.url().startsWith(prefix)) {
-            return false;
+function makeTargetFilter() {
+    const ignoredPrefixes = new Set([
+        'chrome://',
+        'chrome-extension://',
+        'chrome-untrusted://',
+    ]);
+    return function targetFilter(target) {
+        if (target.url() === 'chrome://newtab/') {
+            return true;
         }
-    }
-    return true;
+        // Could be the only page opened in the browser.
+        if (target.url().startsWith('chrome://inspect')) {
+            return true;
+        }
+        for (const prefix of ignoredPrefixes) {
+            if (target.url().startsWith(prefix)) {
+                return false;
+            }
+        }
+        return true;
+    };
 }
-const connectOptions = {
-    targetFilter,
-    // We do not expect any single CDP command to take more than 10sec.
-    protocolTimeout: 10_000,
-};
-export async function ensureBrowserConnected(browserURL) {
+export async function ensureBrowserConnected(options) {
+    const { channel } = options;
     if (browser?.connected) {
         return browser;
     }
-    browser = await puppeteer.connect({
-        ...connectOptions,
-        browserURL,
+    const connectOptions = {
+        targetFilter: makeTargetFilter(),
         defaultViewport: null,
-    });
+        handleDevToolsAsPage: true,
+    };
+    if (options.wsEndpoint) {
+        connectOptions.browserWSEndpoint = options.wsEndpoint;
+        if (options.wsHeaders) {
+            connectOptions.headers = options.wsHeaders;
+        }
+    }
+    else if (options.browserURL) {
+        connectOptions.browserURL = options.browserURL;
+    }
+    else if (channel || options.userDataDir) {
+        const userDataDir = options.userDataDir;
+        if (userDataDir) {
+            // TODO: re-expose this logic via Puppeteer.
+            const portPath = path.join(userDataDir, 'DevToolsActivePort');
+            try {
+                const fileContent = await fs.promises.readFile(portPath, 'utf8');
+                const [rawPort, rawPath] = fileContent
+                    .split('\n')
+                    .map(line => {
+                    return line.trim();
+                })
+                    .filter(line => {
+                    return !!line;
+                });
+                if (!rawPort || !rawPath) {
+                    throw new Error(`Invalid DevToolsActivePort '${fileContent}' found`);
+                }
+                const port = parseInt(rawPort, 10);
+                if (isNaN(port) || port <= 0 || port > 65535) {
+                    throw new Error(`Invalid port '${rawPort}' found`);
+                }
+                const browserWSEndpoint = `ws://127.0.0.1:${port}${rawPath}`;
+                connectOptions.browserWSEndpoint = browserWSEndpoint;
+            }
+            catch (error) {
+                throw new Error(`Could not connect to Chrome in ${userDataDir}. Check if Chrome is running and remote debugging is enabled.`, {
+                    cause: error,
+                });
+            }
+        }
+        else {
+            if (!channel) {
+                throw new Error('Channel must be provided if userDataDir is missing');
+            }
+            connectOptions.channel = (channel === 'stable' ? 'chrome' : `chrome-${channel}`);
+        }
+    }
+    else {
+        throw new Error('Either browserURL, wsEndpoint, channel or userDataDir must be provided');
+    }
+    logger('Connecting Puppeteer to ', JSON.stringify(connectOptions));
+    try {
+        browser = await puppeteer.connect(connectOptions);
+    }
+    catch (err) {
+        throw new Error('Could not connect to Chrome. Check if Chrome is running and remote debugging is enabled by going to chrome://inspect/#remote-debugging.', {
+            cause: err,
+        });
+    }
+    logger('Connected Puppeteer');
     return browser;
 }
 export async function launch(options) {
-    const { channel, executablePath, customDevTools, headless, isolated } = options;
+    const { channel, executablePath, headless, isolated } = options;
     const profileDirName = channel && channel !== 'stable'
         ? `chrome-profile-${channel}`
         : 'chrome-profile';
@@ -69,10 +131,13 @@ export async function launch(options) {
     if (options.stealth) {
         args.push('--disable-blink-features=AutomationControlled', '--disable-features=IsolateOrigins,site-per-process', '--no-first-run', '--no-service-autorun', '--password-store=basic');
     }
-    if (customDevTools) {
-        args.push(`--custom-devtools-frontend=file://${customDevTools}`);
+    if (headless) {
+        args.push('--screen-info={3840x2160}');
     }
     let puppeteerChannel;
+    if (options.devtools) {
+        args.push('--auto-open-devtools-for-tabs');
+    }
     if (!executablePath) {
         puppeteerChannel =
             channel && channel !== 'stable'
@@ -83,8 +148,8 @@ export async function launch(options) {
         // Use puppeteer-extra with stealth plugin if stealth mode is enabled
         const puppeteerInstance = options.stealth ? puppeteerExtra : puppeteer;
         const launchOptions = {
-            ...connectOptions,
             channel: puppeteerChannel,
+            targetFilter: makeTargetFilter(),
             executablePath,
             defaultViewport: null,
             userDataDir,
@@ -92,6 +157,7 @@ export async function launch(options) {
             headless,
             args,
             acceptInsecureCerts: options.acceptInsecureCerts,
+            handleDevToolsAsPage: true,
         };
         // Add ignoreDefaultArgs when stealth is enabled to remove automation flags
         if (options.stealth) {
@@ -116,9 +182,7 @@ export async function launch(options) {
     }
     catch (error) {
         if (userDataDir &&
-            (error.message.includes('The browser is already running') ||
-                error.message.includes('Target closed') ||
-                error.message.includes('Connection closed'))) {
+            error.message.includes('The browser is already running')) {
             throw new Error(`The browser is already running for ${userDataDir}. Use --isolated to run multiple browser instances.`, {
                 cause: error,
             });