opera-devtools-mcp 0.2.4 → 0.4.0

package/build/src/browser.js

@@ -9,9 +9,10 @@ import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { logger } from './logger.js';
 import { puppeteer } from './third_party/index.js';
+import { logger, puppeteerLogger } from './utils/logger.js';
 let browser;
+let browserMode;
 function makeTargetFilter(enableExtensions = false) {
     const ignoredPrefixes = new Set(['chrome://', 'chrome-untrusted://']);
     if (!enableExtensions) {
@@ -42,6 +43,9 @@ export async function ensureBrowserConnected(options) {
         targetFilter: makeTargetFilter(enableExtensions),
         defaultViewport: null,
         handleDevToolsAsPage: true,
+        blocklist: options.blocklist,
+        allowlist: options.allowlist,
+        logger: puppeteerLogger,
     };
     let autoConnect = false;
     if (options.wsEndpoint) {
@@ -95,16 +99,21 @@ export async function ensureBrowserConnected(options) {
     else {
         throw new Error('Either browserURL, wsEndpoint, channel or userDataDir must be provided');
     }
-    logger('Connecting Puppeteer to ', JSON.stringify(connectOptions));
+    logger?.('Connecting Puppeteer to ', JSON.stringify(connectOptions));
     try {
-        browser = await puppeteer.connect(connectOptions);
+        // Assign mode before browser so a concurrent closeBrowser() never sees
+        // `browser` set with `browserMode` still undefined (would fall through
+        // to the disconnect() path and orphan a launched Chrome).
+        const connected = await puppeteer.connect(connectOptions);
+        browserMode = 'connected';
+        browser = connected;
     }
     catch (err) {
         throw new Error(`Could not connect to Chrome. ${autoConnect ? `Check if Chrome is running and remote debugging is enabled by going to chrome://inspect/#remote-debugging.` : `Check if Chrome is running.`}`, {
             cause: err,
         });
     }
-    logger('Connected Puppeteer');
+    logger?.('Connected Puppeteer');
     return browser;
 }
 export function detectDisplay() {
@@ -170,6 +179,9 @@ export async function launch(options) {
             acceptInsecureCerts: options.acceptInsecureCerts,
             handleDevToolsAsPage: true,
             enableExtensions: options.enableExtensions,
+            blocklist: options.blocklist,
+            allowlist: options.allowlist,
+            logger: puppeteerLogger,
         });
         if (options.logFile) {
             // FIXME: we are probably subscribing too late to catch startup logs. We
@@ -200,12 +212,40 @@ export async function ensureBrowserLaunched(options) {
     if (browser?.connected) {
         return browser;
     }
-    browser = await launch(options);
+    // Assign mode before browser; see the connect path above for rationale.
+    const launched = await launch(options);
+    browserMode = 'launched';
+    browser = launched;
     return browser;
 }
 export function getCurrentBrowser() {
     return browser;
 }
+/**
+ * Shutdown hook for the active browser. Closes a launched browser (so the
+ * Chrome subprocess is reaped) or disconnects from an attached browser (so
+ * the user's Chrome instance stays alive). No-op if no browser is active or
+ * the connection has already been dropped. Called from the server entrypoint
+ * on stdin EOF / SIGTERM / SIGINT.
+ */
+export async function closeBrowser() {
+    const b = browser;
+    const mode = browserMode;
+    browser = undefined;
+    browserMode = undefined;
+    if (!b || !b.connected) {
+        return;
+    }
+    if (mode === 'launched') {
+        await b.close().catch(err => {
+            logger?.('Failed to close browser', err);
+        });
+        return;
+    }
+    await b.disconnect().catch(err => {
+        logger?.('Failed to disconnect from browser', err);
+    });
+}
 export async function closeBrowserIfOpen() {
     if (browser?.connected) {
         try {

package/build/src/{PageCollector.js → collectors/PageCollector.js}

@@ -3,10 +3,10 @@
  * 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';
-import { createIdGenerator, stableIdSymbol, } from './utils/id.js';
+import { FakeIssuesManager } from '../devtools/DevtoolsUtils.js';
+import { DevTools } from '../third_party/index.js';
+import { createIdGenerator, stableIdSymbol, } from '../utils/id.js';
+import { logger } from '../utils/logger.js';
 export class UncaughtError {
     details;
     targetId;
@@ -16,113 +16,59 @@ export class UncaughtError {
     }
 }
 export class PageCollector {
-    #browser;
-    #listenersInitializer;
-    #listeners = new WeakMap();
+    pptrPage;
+    #listeners;
     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;
-        }
+    storage = [[]];
+    constructor(page, listeners, maxResourcesPerNavigation) {
+        this.pptrPage = page;
         const idGenerator = createIdGenerator();
-        const storedLists = [[]];
-        this.storage.set(page, storedLists);
-        const listeners = this.#listenersInitializer(value => {
+        const listenerMap = listeners(value => {
             const withId = value;
             withId[stableIdSymbol] = idGenerator();
-            const navigations = this.storage.get(page) ?? [[]];
-            navigations[0].push(withId);
+            this.storage[0].push(withId);
+            if (maxResourcesPerNavigation !== undefined &&
+                this.storage[0].length > maxResourcesPerNavigation) {
+                this.storage[0].splice(0, this.storage[0].length - maxResourcesPerNavigation);
+            }
         });
-        listeners['framenavigated'] = (frame) => {
+        listenerMap['framenavigated'] = (frame) => {
             // Only split the storage on main frame navigation
-            if (frame !== page.mainFrame()) {
+            if (frame !== this.pptrPage.mainFrame()) {
                 return;
             }
-            this.splitAfterNavigation(page);
+            this.splitAfterNavigation();
         };
-        for (const [name, listener] of Object.entries(listeners)) {
-            page.on(name, listener);
+        for (const [name, listener] of Object.entries(listenerMap)) {
+            this.pptrPage.on(name, listener);
         }
-        this.#listeners.set(page, listeners);
+        this.#listeners = listenerMap;
     }
-    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);
+    dispose() {
+        if (this.#listeners) {
+            for (const [name, listener] of Object.entries(this.#listeners)) {
+                this.pptrPage.off(name, listener);
             }
         }
-        this.storage.delete(page);
     }
-    getData(page, includePreservedData) {
-        const navigations = this.storage.get(page);
-        if (!navigations) {
-            return [];
-        }
+    splitAfterNavigation() {
+        // Add the latest navigation first
+        this.storage.unshift([]);
+        this.storage.splice(this.maxNavigationSaved);
+    }
+    getData(includePreservedData) {
         if (!includePreservedData) {
-            return navigations[0];
+            return this.storage[0];
         }
         const data = [];
         for (let index = this.maxNavigationSaved; index >= 0; index--) {
-            if (navigations[index]) {
-                data.push(...navigations[index]);
+            if (this.storage[index]) {
+                data.push(...this.storage[index]);
             }
         }
         return data;
@@ -130,23 +76,15 @@ export class PageCollector {
     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;
+    getById(stableId) {
+        const item = this.find(item => item[stableIdSymbol] === stableId);
+        if (!item) {
+            throw new Error('Request not found for selected page');
         }
-        throw new Error('Request not found for selected page');
+        return item;
     }
-    find(page, filter) {
-        const navigations = this.storage.get(page);
-        if (!navigations) {
-            return;
-        }
-        for (const navigation of navigations) {
+    find(filter) {
+        for (const navigation of this.storage) {
             const item = navigation.find(filter);
             if (item) {
                 return item;
@@ -156,19 +94,15 @@ export class PageCollector {
     }
 }
 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();
-        }
+    #subscriber;
+    constructor(page, listeners) {
+        super(page, listeners);
+        this.#subscriber = new PageEventSubscriber(this.pptrPage);
+        this.#subscriber.subscribe();
     }
-    cleanupPageDestroyed(page) {
-        super.cleanupPageDestroyed(page);
-        this.#subscribedPages.get(page)?.unsubscribe();
-        this.#subscribedPages.delete(page);
+    dispose() {
+        super.dispose();
+        this.#subscriber?.unsubscribe();
     }
 }
 class PageEventSubscriber {
@@ -194,7 +128,7 @@ class PageEventSubscriber {
         this.#issueAggregator = new DevTools.IssueAggregator(this.#issueManager);
         this.#issueAggregator.addEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedIssue);
     }
-    async subscribe() {
+    subscribe() {
         this.#resetIssueAggregator();
         this.#page.on('framenavigated', this.#onFrameNavigated);
         this.#page.on('issue', this.#onIssueAdded);
@@ -232,16 +166,16 @@ class PageEventSubscriber {
     };
     #onIssueAdded = (inspectorIssue) => {
         try {
-            // DevTools currently defines this protocol issue code but has no
-            // IssuesManager handler for it, so calling into the mapper only warns.
-            if (String(inspectorIssue.code) === 'PerformanceIssue') {
+            // @ts-expect-error The types are missmatched but they
+            // are coming from CDP
+            if (!DevTools.isIssueCodeSupported(inspectorIssue.code)) {
                 return;
             }
             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);
+                logger?.('No issue mapping for for the issue: ', inspectorIssue.code);
                 return;
             }
             const primaryKey = issue.primaryKey();
@@ -256,28 +190,25 @@ class PageEventSubscriber {
             });
         }
         catch (error) {
-            logger('Error creating a new issue', error);
+            logger?.('Error creating a new issue', error);
         }
     };
 }
 export class NetworkCollector extends PageCollector {
-    constructor(browser, listeners = collect => {
+    static MAX_REQUESTS_PER_NAVIGATION = 1_000;
+    constructor(page, maxRequestsPerNavigation = NetworkCollector.MAX_REQUESTS_PER_NAVIGATION, listeners = collect => {
         return {
             request: req => {
                 collect(req);
             },
         };
     }) {
-        super(browser, listeners);
+        super(page, listeners, maxRequestsPerNavigation);
     }
-    splitAfterNavigation(page) {
-        const navigations = this.storage.get(page) ?? [];
-        if (!navigations) {
-            return;
-        }
-        const requests = navigations[0];
+    splitAfterNavigation() {
+        const requests = this.storage[0];
         const lastRequestIdx = requests.findLastIndex(request => {
-            return request.frame() === page.mainFrame()
+            return request.frame() === this.pptrPage.mainFrame()
                 ? request.isNavigationRequest()
                 : false;
         });
@@ -286,12 +217,12 @@ export class NetworkCollector extends PageCollector {
         // Keep the reference
         if (lastRequestIdx !== -1) {
             const fromCurrentNavigation = requests.splice(lastRequestIdx);
-            navigations.unshift(fromCurrentNavigation);
+            this.storage.unshift(fromCurrentNavigation);
         }
         else {
-            navigations.unshift([]);
+            this.storage.unshift([]);
         }
-        navigations.splice(this.maxNavigationSaved);
+        this.storage.splice(this.maxNavigationSaved);
     }
 }
 //# sourceMappingURL=PageCollector.js.map

package/build/src/collectors/ServiceWorkerCollector.js

@@ -0,0 +1,171 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { UncaughtError } from './PageCollector.js';
+import { createIdGenerator, stableIdSymbol } from '../utils/id.js';
+const CHROME_EXTENSION_PREFIX = 'chrome-extension://';
+export class ServiceWorkerSubscriber {
+    #target;
+    #callback;
+    #session;
+    #worker;
+    constructor(target, callback) {
+        this.#target = target;
+        this.#callback = callback;
+    }
+    async subscribe() {
+        this.#session = await this.#target.createCDPSession();
+        await this.#session.send('Runtime.enable');
+        this.#session.on('Runtime.exceptionThrown', this.#onExceptionThrown);
+        this.#worker = (await this.#target.worker()) ?? undefined;
+        if (this.#worker) {
+            this.#worker.on('console', this.#onConsole);
+        }
+    }
+    async unsubscribe() {
+        if (this.#worker) {
+            this.#worker.off('console', this.#onConsole);
+        }
+        await this.#session?.detach();
+    }
+    #onConsole = (message) => {
+        this.#callback(message);
+    };
+    #onExceptionThrown = (event) => {
+        const url = this.#target.url();
+        const extensionId = extractExtensionId(url);
+        if (extensionId) {
+            this.#callback(new UncaughtError(event.exceptionDetails, extensionId));
+        }
+    };
+}
+export class ServiceWorkerConsoleCollector {
+    #storage = new Map();
+    #maxLogs;
+    #browser;
+    #serviceWorkerSubscribers = new Map();
+    #idGenerator = createIdGenerator();
+    constructor(browser, maxLogs = 1000) {
+        this.#browser = browser;
+        this.#maxLogs = maxLogs;
+    }
+    async init(workers) {
+        if (!this.#browser) {
+            return;
+        }
+        this.#browser.on('targetcreated', this.#onTargetCreated);
+        this.#browser.on('targetdestroyed', this.#onTargetDestroyed);
+        for (const worker of workers) {
+            void this.#onTargetCreated(worker.target);
+        }
+    }
+    dispose() {
+        if (!this.#browser) {
+            return;
+        }
+        this.#browser.off('targetcreated', this.#onTargetCreated);
+        this.#browser.off('targetdestroyed', this.#onTargetDestroyed);
+        for (const subscriber of this.#serviceWorkerSubscribers.values()) {
+            subscriber.unsubscribe().catch(err => {
+                if (err instanceof Error &&
+                    !err.message.includes('Target closed') &&
+                    !err.message.includes('Session closed')) {
+                    // Swallow error as we are tearing down the system
+                }
+            });
+        }
+        this.#serviceWorkerSubscribers.clear();
+    }
+    #onTargetCreated = async (target) => {
+        if (this.#serviceWorkerSubscribers.has(target)) {
+            return;
+        }
+        const origin = target.url();
+        if (target.type() === 'service_worker' && isExtensionOrigin(origin)) {
+            const extensionId = extractExtensionId(origin);
+            if (!extensionId) {
+                return;
+            }
+            const subscriber = new ServiceWorkerSubscriber(target, item => {
+                this.addLog(extensionId, item);
+            });
+            try {
+                await subscriber.subscribe();
+            }
+            catch (err) {
+                if (err instanceof Error &&
+                    !err.message.includes('Target closed') &&
+                    !err.message.includes('Session closed')) {
+                    throw err;
+                }
+            }
+            this.#serviceWorkerSubscribers.set(target, subscriber);
+        }
+    };
+    #onTargetDestroyed = async (target) => {
+        const subscriber = this.#serviceWorkerSubscribers.get(target);
+        if (subscriber) {
+            try {
+                await subscriber.unsubscribe();
+            }
+            catch (err) {
+                if (err instanceof Error &&
+                    !err.message.includes('Target closed') &&
+                    !err.message.includes('Session closed')) {
+                    throw err;
+                }
+            }
+            this.#serviceWorkerSubscribers.delete(target);
+        }
+    };
+    addLog(extensionId, log) {
+        const logs = this.#storage.get(extensionId) ?? [];
+        const withId = log;
+        withId[stableIdSymbol] = this.#idGenerator();
+        logs.push(withId);
+        if (logs.length > this.#maxLogs) {
+            logs.shift();
+        }
+        this.#storage.set(extensionId, logs);
+    }
+    getData(extensionId) {
+        return this.#storage.get(extensionId) ?? [];
+    }
+    getById(extensionId, stableId) {
+        const logs = this.#storage.get(extensionId);
+        if (!logs) {
+            throw new Error('No logs found for selected extension');
+        }
+        const item = logs.find(item => item[stableIdSymbol] === stableId);
+        if (item) {
+            return item;
+        }
+        throw new Error('Log not found for selected extension');
+    }
+    find(extensionId, filter) {
+        const logs = this.#storage.get(extensionId);
+        if (!logs) {
+            return;
+        }
+        return logs.find(filter);
+    }
+    clearLogs(extensionId) {
+        this.#storage.delete(extensionId);
+    }
+}
+function extractExtensionId(origin) {
+    if (!origin || !isExtensionOrigin(origin)) {
+        return null;
+    }
+    const pathPart = origin.substring(CHROME_EXTENSION_PREFIX.length);
+    const slashIndex = pathPart.indexOf('/');
+    // if there's no / it means that pathPart is now the extensionId, otherwise
+    // we take everything until the first /
+    return slashIndex === -1 ? pathPart : pathPart.substring(0, slashIndex);
+}
+function isExtensionOrigin(origin) {
+    return origin.startsWith(CHROME_EXTENSION_PREFIX);
+}
+//# sourceMappingURL=ServiceWorkerCollector.js.map