opera-devtools-mcp 0.2.4 → 0.4.0

package/build/src/{DevtoolsUtils.js → devtools/DevtoolsUtils.js}

@@ -3,9 +3,8 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { PuppeteerDevToolsConnection } from './DevToolsConnectionAdapter.js';
-import { Mutex } from './Mutex.js';
-import { DevTools } from './third_party/index.js';
+import { DevTools } from '../third_party/index.js';
+import { McpHostBindingAdapter } from './McpHostBindingAdapter.js';
 /**
  * A mock implementation of an issues manager that only implements the methods
  * that are actually used by the IssuesAggregator
@@ -16,82 +15,83 @@ export class FakeIssuesManager extends DevTools.Common.ObjectWrapper
         return [];
     }
 }
-// DevTools CDP errors can get noisy.
-DevTools.ProtocolClient.InspectorBackend.test.suppressRequestErrors = true;
-DevTools.I18n.DevToolsLocale.DevToolsLocale.instance({
-    create: true,
-    data: {
-        navigatorLanguage: 'en-US',
-        settingLanguage: 'en-US',
-        lookupClosestDevToolsLocale: l => l,
-    },
-});
-DevTools.I18n.i18n.registerLocaleDataForTest('en-US', {});
-DevTools.Formatter.FormatterWorkerPool.FormatterWorkerPool.instance({
-    forceNew: true,
-    entrypointURL: import.meta
-        .resolve('./third_party/devtools-formatter-worker.js'),
-});
-export class UniverseManager {
-    #browser;
-    #createUniverseFor;
-    #universes = new WeakMap();
-    /** Guard access to #universes so we don't create unnecessary universes */
-    #mutex = new Mutex();
-    constructor(browser, factory = DEFAULT_FACTORY) {
-        this.#browser = browser;
-        this.#createUniverseFor = factory;
-    }
-    async init(pages) {
-        try {
-            await this.#mutex.acquire();
-            const promises = [];
-            for (const page of pages) {
-                promises.push(this.#createUniverseFor(page).then(targetUniverse => this.#universes.set(page, targetUniverse)));
-            }
-            this.#browser.on('targetcreated', this.#onTargetCreated);
-            this.#browser.on('targetdestroyed', this.#onTargetDestroyed);
-            await Promise.all(promises);
-        }
-        finally {
-            this.#mutex.release();
-        }
-    }
-    get(page) {
-        return this.#universes.get(page) ?? null;
-    }
-    dispose() {
-        this.#browser.off('targetcreated', this.#onTargetCreated);
-        this.#browser.off('targetdestroyed', this.#onTargetDestroyed);
+export function overrideDevToolsGlobals({ loadResource, }) {
+    DevTools.Host.InspectorFrontendHost.installInspectorFrontendHost(new McpHostBindingAdapter(loadResource));
+    // DevTools CDP errors can get noisy.
+    DevTools.ProtocolClient.InspectorBackend.test.suppressRequestErrors = true;
+    // Stub out Network emulation commands on the DevTools Agent prototype globally.
+    // This prevents the DevTools Frontend from ever resetting/clearing Puppeteer's
+    // active network blocking/throttling rules during target setup or session lifetime.
+    const networkAgentPrototype = DevTools.ProtocolClient.InspectorBackend.inspectorBackend.agentPrototypes.get('Network');
+    if (networkAgentPrototype) {
+        Object.defineProperty(networkAgentPrototype, 'invoke_emulateNetworkConditionsByRule', {
+            value: () => {
+                return Promise.resolve({
+                    ruleIds: [],
+                    getError: () => undefined,
+                });
+            },
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+        Object.defineProperty(networkAgentPrototype, 'invoke_overrideNetworkState', {
+            value: () => {
+                return Promise.resolve({
+                    getError: () => undefined,
+                });
+            },
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+        Object.defineProperty(networkAgentPrototype, 'invoke_enable', {
+            value: () => {
+                return Promise.resolve({
+                    getError: () => undefined,
+                });
+            },
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+        Object.defineProperty(networkAgentPrototype, 'invoke_disable', {
+            value: () => {
+                return Promise.resolve({
+                    getError: () => undefined,
+                });
+            },
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+        Object.defineProperty(networkAgentPrototype, 'invoke_setBlockedURLs', {
+            value: () => {
+                return Promise.resolve({
+                    getError: () => undefined,
+                });
+            },
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
     }
-    #onTargetCreated = async (target) => {
-        const page = await target.page();
-        try {
-            await this.#mutex.acquire();
-            if (!page || this.#universes.has(page)) {
-                return;
-            }
-            this.#universes.set(page, await this.#createUniverseFor(page));
-        }
-        finally {
-            this.#mutex.release();
-        }
-    };
-    #onTargetDestroyed = async (target) => {
-        const page = await target.page();
-        try {
-            await this.#mutex.acquire();
-            if (!page || !this.#universes.has(page)) {
-                return;
-            }
-            this.#universes.delete(page);
-        }
-        finally {
-            this.#mutex.release();
-        }
-    };
+    DevTools.I18n.DevToolsLocale.DevToolsLocale.instance({
+        create: true,
+        data: {
+            navigatorLanguage: 'en-US',
+            settingLanguage: 'en-US',
+            lookupClosestDevToolsLocale: l => l,
+        },
+    });
+    DevTools.I18n.i18n.registerLocaleDataForTest('en-US', {});
+    DevTools.Formatter.FormatterWorkerPool.FormatterWorkerPool.instance({
+        forceNew: true,
+        entrypointURL: import.meta
+            .resolve('../third_party/devtools-formatter-worker.js'),
+    });
 }
-const DEFAULT_FACTORY = async (page) => {
+export async function createTargetUniverse(session) {
     const settingStorage = new DevTools.Common.Settings.SettingsStorage({});
     const universe = new DevTools.Foundation.Universe.Universe({
         settingsCreationOptions: {
@@ -101,23 +101,29 @@ const DEFAULT_FACTORY = async (page) => {
             settingRegistrations: DevTools.Common.SettingRegistration.getRegisteredSettings(),
         },
         overrideAutoStartModels: new Set([DevTools.DebuggerModel]),
+        hostConfig: {},
+        inspectorFrontendHost: DevTools.Host.InspectorFrontendHost.InspectorFrontendHostInstance,
+        supportsEmulation: false,
     });
-    const session = await page.createCDPSession();
-    const connection = new PuppeteerDevToolsConnection(session);
+    const setting = universe.settings.resolve(DevTools.SourceMapManager.lazyLoadingSettingDescriptor);
+    setting.set(true);
+    const skipAllPausesSetting = universe.settings.resolve(DevTools.skipAllPausesSettingDescriptor);
+    skipAllPausesSetting.set(true);
+    // @ts-expect-error devtools-frontend has diffrent types.
+    const connection = new DevTools.PuppeteerDevToolsConnection(session);
     const targetManager = universe.context.get(DevTools.TargetManager);
-    targetManager.observeModels(DevTools.DebuggerModel, SKIP_ALL_PAUSES);
+    targetManager.observeModels(DevTools.NetworkManager.NetworkManager, DISABLE_NETWORK);
     const target = targetManager.createTarget('main', '', 'frame', // eslint-disable-line @typescript-eslint/no-explicit-any
     /* parentTarget */ null, session.id(), undefined, connection);
-    return { target, universe };
-};
-// We don't want to pause any DevTools universe session ever on the MCP side.
+    return { target, universe, session };
+}
+// Not recording network requests in the DevTools universe.
 //
-// Note that calling `setSkipAllPauses` only affects the session on which it was
-// sent. This means DevTools can still pause, step and do whatever. We just won't
-// see the `Debugger.paused`/`Debugger.resumed` events on the MCP side.
-const SKIP_ALL_PAUSES = {
+// The network requests are collected through pptr and there isn't a use case for
+// enabling devtools SDK's network domain.
+const DISABLE_NETWORK = {
     modelAdded(model) {
-        void model.agent.invoke_setSkipAllPauses({ skip: true });
+        void model.target().networkAgent().invoke_disable();
     },
     modelRemoved() {
         // Do nothing.

package/build/src/devtools/McpHostBindingAdapter.js

@@ -0,0 +1,165 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { DevTools } from '../third_party/index.js';
+/**
+ * BaseClass that is noop or throws for methods.
+ * the McpHostBindingAdapter should only implement methods
+ * that it needs to support.
+ */
+class BaseMcpHostBindingAdapter {
+    connectAutomaticFileSystem() { }
+    disconnectAutomaticFileSystem() { }
+    addFileSystem() { }
+    loadCompleted() { }
+    indexPath() { }
+    setInspectedPageBounds() { }
+    showCertificateViewer() { }
+    setWhitelistedShortcuts() { }
+    setEyeDropperActive() { }
+    inspectElementCompleted() { }
+    openInNewTab() { }
+    openSearchResultsInNewTab() { }
+    showItemInFolder() { }
+    removeFileSystem() { }
+    requestFileSystems() { }
+    save() { }
+    append() { }
+    close() { }
+    searchInPath() { }
+    stopIndexing() { }
+    bringToFront() { }
+    closeWindow() { }
+    copyText() { }
+    inspectedURLChanged() { }
+    isolatedFileSystem() {
+        throw new Error('Not implemented');
+    }
+    registerPreference() { }
+    getPreferences() { }
+    getPreference() { }
+    setPreference() { }
+    removePreference() { }
+    clearPreferences() { }
+    getSyncInformation() { }
+    getHostConfig() { }
+    upgradeDraggedFileSystemPermissions() { }
+    platform() {
+        throw new Error('Not implemented');
+    }
+    recordCountHistogram() { }
+    recordEnumeratedHistogram() { }
+    recordPerformanceHistogram() { }
+    recordPerformanceHistogramMedium() { }
+    recordUserMetricsAction() { }
+    recordNewBadgeUsage() { }
+    sendMessageToBackend() { }
+    setDevicesDiscoveryConfig() { }
+    setDevicesUpdatesEnabled() { }
+    openRemotePage() { }
+    openNodeFrontend() { }
+    setInjectedScriptForOrigin() { }
+    setIsDocked() { }
+    showSurvey() { }
+    canShowSurvey() { }
+    zoomFactor() {
+        throw new Error('Not implemented');
+    }
+    zoomIn() { }
+    zoomOut() { }
+    resetZoom() { }
+    showContextMenuAtPoint() { }
+    reattach() { }
+    readyForTest() { }
+    connectionReady() { }
+    setOpenNewWindowForPopups() { }
+    isHostedMode() {
+        throw new Error('Not implemented');
+    }
+    setAddExtensionCallback() { }
+    initialTargetId() {
+        throw new Error('Not implemented');
+    }
+    doAidaConversation(_request, _streamId, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    registerAidaClientEvent(_request, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    aidaCodeComplete(_request, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    dispatchHttpRequest(_request, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    recordImpression() { }
+    recordResize() { }
+    recordClick() { }
+    recordHover() { }
+    recordDrag() { }
+    recordChange() { }
+    recordKeyDown() { }
+    recordSettingAccess() { }
+    recordFunctionCall() { }
+    setChromeFlag() { }
+    requestRestart() { }
+    loadNetworkResource(_urlString, _headers, _streamId, _callback) { }
+}
+export class McpHostBindingAdapter extends BaseMcpHostBindingAdapter {
+    #loadResource;
+    constructor(loadResource) {
+        super();
+        this.#loadResource = loadResource;
+    }
+    isolatedFileSystem() {
+        return null;
+    }
+    platform() {
+        switch (process.platform) {
+            case 'darwin':
+                return 'mac';
+            case 'win32':
+                return 'windows';
+            default:
+                return 'linux';
+        }
+    }
+    zoomFactor() {
+        return 1;
+    }
+    isHostedMode() {
+        return true;
+    }
+    initialTargetId() {
+        return Promise.resolve(null);
+    }
+    loadNetworkResource(urlString, _headers, streamId, callback) {
+        if (!URL.canParse(urlString)) {
+            callback({
+                statusCode: 404,
+                urlValid: false,
+            });
+            return;
+        }
+        this.#loadResource(urlString)
+            .then(content => {
+            DevTools.Host.ResourceLoader.streamWrite(streamId, content);
+            callback({ statusCode: 200 });
+        })
+            .catch(() => {
+            callback({ statusCode: 404 });
+        });
+    }
+}
+//# sourceMappingURL=McpHostBindingAdapter.js.map

package/build/src/{issue-descriptions.js → devtools/issueDescriptions.js}

@@ -5,7 +5,7 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-const DESCRIPTIONS_PATH = path.join(import.meta.dirname, 'third_party/issue-descriptions');
+const DESCRIPTIONS_PATH = path.join(import.meta.dirname, '../third_party/issue-descriptions');
 let issueDescriptions = {};
 /**
  * Reads all issue descriptions from the filesystem into memory.
@@ -16,11 +16,13 @@ export async function loadIssueDescriptions() {
     }
     const files = await fs.promises.readdir(DESCRIPTIONS_PATH);
     const descriptions = {};
-    for (const file of files) {
-        if (!file.endsWith('.md')) {
-            continue;
-        }
+    const results = await Promise.all(files
+        .filter(file => file.endsWith('.md'))
+        .map(async (file) => {
         const content = await fs.promises.readFile(path.join(DESCRIPTIONS_PATH, file), 'utf-8');
+        return { file, content };
+    }));
+    for (const { file, content } of results) {
         descriptions[file] = content;
     }
     issueDescriptions = descriptions;
@@ -37,4 +39,4 @@ export const ISSUE_UTILS = {
     loadIssueDescriptions,
     getIssueDescription,
 };
-//# sourceMappingURL=issue-descriptions.js.map
+//# sourceMappingURL=issueDescriptions.js.map

package/build/src/formatters/ConsoleFormatter.js

@@ -3,8 +3,8 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createStackTraceForConsoleMessage, SymbolizedError, } from '../DevtoolsUtils.js';
-import { UncaughtError } from '../PageCollector.js';
+import { createStackTraceForConsoleMessage, SymbolizedError, } from '../devtools/DevtoolsUtils.js';
+import { UncaughtError } from '../collectors/PageCollector.js';
 import * as DevTools from '../third_party/index.js';
 export class ConsoleFormatter {
     #id;
@@ -14,6 +14,7 @@ export class ConsoleFormatter {
     #resolvedArgs;
     #stack;
     #cause;
+    #includeStackInConcise;
     isIgnored;
     constructor(params) {
         this.#id = params.id;
@@ -23,6 +24,7 @@ export class ConsoleFormatter {
         this.#resolvedArgs = params.resolvedArgs ?? [];
         this.#stack = params.stack;
         this.#cause = params.cause;
+        this.#includeStackInConcise = params.includeStackInConcise ?? false;
         this.isIgnored = params.isIgnored;
     }
     static async from(msg, options) {
@@ -45,7 +47,7 @@ export class ConsoleFormatter {
                 devTools: options?.devTools,
                 details: msg.details,
                 targetId: msg.targetId,
-                includeStackAndCause: options?.fetchDetailedData,
+                includeStackAndCause: options?.fetchDetailedData || options?.fetchStackTrace,
                 resolvedStackTraceForTesting: options?.resolvedStackTraceForTesting,
                 resolvedCauseForTesting: options?.resolvedCauseForTesting,
             });
@@ -55,6 +57,7 @@ export class ConsoleFormatter {
                 text: error.message,
                 stack: error.stackTrace,
                 cause: error.cause,
+                includeStackInConcise: options.fetchStackTrace,
                 isIgnored,
             });
         }
@@ -86,7 +89,8 @@ export class ConsoleFormatter {
         if (options.resolvedStackTraceForTesting) {
             stack = options.resolvedStackTraceForTesting;
         }
-        else if (options.fetchDetailedData && options.devTools) {
+        else if ((options.fetchDetailedData || options.fetchStackTrace) &&
+            options.devTools) {
             try {
                 stack = await createStackTraceForConsoleMessage(options.devTools, msg);
             }
@@ -101,6 +105,7 @@ export class ConsoleFormatter {
             argCount: resolvedArgs.length || msg.args().length,
             resolvedArgs,
             stack,
+            includeStackInConcise: options.fetchStackTrace,
             isIgnored,
         });
     }
@@ -112,6 +117,15 @@ export class ConsoleFormatter {
     toStringDetailed() {
         return convertConsoleMessageConciseDetailedToString(this.toJSONDetailed());
     }
+    #getText() {
+        if (this.#text) {
+            return this.#text;
+        }
+        if (this.#resolvedArgs.length > 0) {
+            return formatArg(this.#resolvedArgs[0], this);
+        }
+        return '';
+    }
     #getArgs() {
         if (this.#resolvedArgs.length > 0) {
             const args = [...this.#resolvedArgs];
@@ -124,12 +138,18 @@ export class ConsoleFormatter {
         return [];
     }
     toJSON() {
-        return {
+        const json = {
             type: this.#type,
-            text: this.#text,
+            text: this.#getText(),
             argsCount: this.#argCount,
             id: this.#id,
         };
+        if (this.#includeStackInConcise && this.#stack) {
+            json.stackTrace = formatStackTrace(this.#stack, this.#cause, this, {
+                includeNote: false,
+            });
+        }
+        return json;
     }
     /**
      * Groups consecutive messages with the same type, text, and argument count.
@@ -143,7 +163,7 @@ export class ConsoleFormatter {
                 prev.message instanceof ConsoleFormatter &&
                 msg instanceof ConsoleFormatter &&
                 prev.message.#type === msg.#type &&
-                prev.message.#text === msg.#text &&
+                prev.message.#getText() === msg.#getText() &&
                 prev.message.#argCount === msg.#argCount) {
                 prev.count++;
             }
@@ -157,6 +177,9 @@ export class ConsoleFormatter {
                 type: message.#type,
                 text: message.#text,
                 argCount: message.#argCount,
+                stack: message.#stack,
+                cause: message.#cause,
+                includeStackInConcise: message.#includeStackInConcise,
                 isIgnored: message.isIgnored,
             }, count)
             : message);
@@ -165,7 +188,7 @@ export class ConsoleFormatter {
         return {
             id: this.#id,
             type: this.#type,
-            text: this.#text,
+            text: this.#getText(),
             argsCount: this.#argCount,
             args: this.#getArgs().map(arg => formatArg(arg, this)),
             stackTrace: this.#stack
@@ -191,7 +214,15 @@ export class GroupedConsoleFormatter extends ConsoleFormatter {
 }
 function convertConsoleMessageConciseToString(msg) {
     const countSuffix = msg.count && msg.count > 1 ? ` [${msg.count} times]` : '';
-    return `msgid=${msg.id} [${msg.type}] ${msg.text} (${msg.argsCount} args)${countSuffix}`;
+    const messageLine = `msgid=${msg.id} [${msg.type}] ${msg.text} (${msg.argsCount} args)${countSuffix}`;
+    if (!msg.stackTrace) {
+        return messageLine;
+    }
+    const indentedStackTrace = msg.stackTrace
+        .split('\n')
+        .map(line => `  ${line}`)
+        .join('\n');
+    return `${messageLine}\n${indentedStackTrace}`;
 }
 function convertConsoleMessageConciseDetailedToString(msg) {
     const result = [
@@ -227,14 +258,16 @@ function formatArg(arg, formatter) {
     return typeof arg === 'object' ? JSON.stringify(arg) : String(arg);
 }
 const STACK_TRACE_MAX_LINES = 50;
-function formatStackTrace(stackTrace, cause, formatter) {
+function formatStackTrace(stackTrace, cause, formatter, options) {
     const lines = formatStackTraceInner(stackTrace, cause, formatter);
     const includedLines = lines.slice(0, STACK_TRACE_MAX_LINES);
     const reminderCount = lines.length - includedLines.length;
     return [
         ...includedLines,
         reminderCount > 0 ? `... and ${reminderCount} more frames` : '',
-        'Note: line and column numbers use 1-based indexing',
+        options?.includeNote === false
+            ? ''
+            : 'Note: line and column numbers use 1-based indexing',
     ]
         .filter(line => !!line)
         .join('\n');