opera-devtools-mcp 0.2.4 → 0.3.0

package/build/src/index.js

@@ -5,22 +5,43 @@
  *
  * Modified by Opera Software AS.
  */
-import { closeBrowserIfOpen, ensureBrowserConnected, ensureBrowserLaunched, getCurrentBrowser, } from './browser.js';
-import { loadIssueDescriptions } from './issue-descriptions.js';
-import { logger } from './logger.js';
+import { ensureBrowserConnected, ensureBrowserLaunched } from './browser.js';
+import { loadIssueDescriptions } from './devtools/issueDescriptions.js';
 import { McpContext } from './McpContext.js';
-import { McpResponse } from './McpResponse.js';
-import { Mutex } from './Mutex.js';
-import { SlimMcpResponse } from './SlimMcpResponse.js';
-import { bucketizeLatency } from './telemetry/metricUtils.js';
+import { BROWSER_EXPOSURE_DISCLAIMER, showUsageStatisticsDisclaimer, } from './opera/policy.js';
+import { createOperaToolHooks } from './opera/toolHandlerHooks.js';
+import { buildLaunchOptions } from './opera/browserLaunch.js';
+import { ClearcutLogger } from './telemetry/ClearcutLogger.js';
+import { FilePersistence } from './telemetry/persistence.js';
 import { McpServer, SetLevelRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, } from './third_party/index.js';
-import { ToolCategory } from './tools/categories.js';
-import { pageIdSchema } from './tools/ToolDefinition.js';
+import { ToolHandler } from './ToolHandler.js';
 import { createTools } from './tools/tools.js';
+import { logger } from './utils/logger.js';
+import { Mutex } from './third_party/index.js';
 import { VERSION } from './version.js';
 export { buildFlag } from './ToolHandler.js';
+/**
+ * Timeout for a `roots/list` that a tool call is waiting on, matching the 5s
+ * default used for page operations. `getContext()` awaits it while
+ * `ToolHandler` holds the tool mutex, so leaving it unbounded lets a client
+ * that negotiates `roots` but does not answer block every tool for the SDK's
+ * default of 60s. Background refreshes are not bounded by this, so roots a
+ * slow client sends late still land.
+ */
+const ROOTS_REQUEST_TIMEOUT = 5_000;
 export async function createMcpServer(serverArgs, options) {
-    let clearcutLogger;
+    // Opera forces `usageStatistics` off in ./opera/policy.ts, so this stays
+    // dormant. Kept identical to upstream so the seam is the policy, not this file.
+    if (serverArgs.usageStatistics) {
+        ClearcutLogger.initialize({
+            persistence: new FilePersistence(),
+            logFile: serverArgs.logFile,
+            appVersion: VERSION,
+            clearcutEndpoint: serverArgs.clearcutEndpoint,
+            clearcutForceFlushIntervalMs: serverArgs.clearcutForceFlushIntervalMs,
+            clearcutIncludePidHeader: serverArgs.clearcutIncludePidHeader,
+        });
+    }
     const server = new McpServer({
         name: 'chrome_devtools',
         title: 'Chrome DevTools MCP server',
@@ -29,22 +50,30 @@ export async function createMcpServer(serverArgs, options) {
     server.server.setRequestHandler(SetLevelRequestSchema, () => {
         return {};
     });
-    const updateRoots = async () => {
+    // Roots are client state rather than browser state, so the last listing stays
+    // valid across browser reconnects and only the client can invalidate it, via
+    // the `roots/list_changed` notification handled below
+    let lastRoots;
+    // `timeout` is only passed where a tool call is waiting on the result – the
+    // background refreshes below block nobody, so bounding them would just discard
+    // roots a slow client was about to send
+    const updateRoots = async (timeout) => {
         if (!server.server.getClientCapabilities()?.roots) {
             return;
         }
         try {
-            const roots = await server.server.request({ method: 'roots/list' }, ListRootsResultSchema);
-            context?.setRoots(roots.roots);
+            const roots = await server.server.request({ method: 'roots/list' }, ListRootsResultSchema, timeout === undefined ? undefined : { timeout });
+            lastRoots = roots.roots;
+            context?.setRoots(lastRoots);
         }
         catch (e) {
-            logger('Failed to list roots', e);
+            logger?.('Failed to list roots', e);
         }
     };
     server.server.oninitialized = () => {
         const clientName = server.server.getClientVersion()?.name;
         if (clientName) {
-            clearcutLogger?.setClientName(clientName);
+            ClearcutLogger.get()?.setClientName(clientName);
         }
         if (server.server.getClientCapabilities()?.roots) {
             void updateRoots();
@@ -52,16 +81,22 @@ export async function createMcpServer(serverArgs, options) {
                 void updateRoots();
             });
         }
+        else if (!serverArgs.allowUnrestrictedPaths) {
+            console.warn('[chrome-devtools-mcp] The connecting client did not negotiate the MCP roots ' +
+                'capability. File-writing tools will be restricted to the OS temp directory. ' +
+                'To restore the previous unrestricted behavior, start the server with ' +
+                '--allow-unrestricted-paths.');
+        }
     };
     let context;
-    let browserHasOperaFlags = false;
     async function getContext() {
-        const chromeArgs = (serverArgs.chromeArg ?? []).map(String);
-        const ignoreDefaultChromeArgs = (serverArgs.ignoreDefaultChromeArg ?? []).map(String);
-        if (serverArgs.proxyServer) {
-            chromeArgs.push(`--proxy-server=${serverArgs.proxyServer}`);
-        }
         const devtools = serverArgs.experimentalDevtools ?? false;
+        const blocklist = serverArgs.blockedUrlPattern
+            ? serverArgs.blockedUrlPattern.map(String)
+            : undefined;
+        const allowlist = serverArgs.allowedUrlPattern
+            ? serverArgs.allowedUrlPattern.map(String)
+            : undefined;
         const browser = serverArgs.browserUrl || serverArgs.wsEndpoint || serverArgs.autoConnect
             ? await ensureBrowserConnected({
                 browserURL: serverArgs.browserUrl,
@@ -73,232 +108,63 @@ export async function createMcpServer(serverArgs, options) {
                     : undefined,
                 userDataDir: serverArgs.userDataDir,
                 devtools,
+                blocklist,
+                allowlist,
             })
-            : await ensureBrowserLaunched({
-                headless: serverArgs.headless,
-                executablePath: serverArgs.executablePath,
-                channel: serverArgs.channel,
-                isolated: serverArgs.isolated ?? false,
-                userDataDir: serverArgs.userDataDir,
-                logFile: options.logFile,
-                viewport: serverArgs.viewport,
-                chromeArgs,
-                ignoreDefaultChromeArgs,
-                acceptInsecureCerts: serverArgs.acceptInsecureCerts,
+            : await ensureBrowserLaunched(
+            // Pass the already-derived values so the launched browser uses the
+            // exact same flags as the connected branch and `McpContext`.
+            buildLaunchOptions(serverArgs, options.logFile, {
                 devtools,
-                enableExtensions: serverArgs.categoryExtensions,
-                viaCli: serverArgs.viaCli,
-            });
+                blocklist,
+                allowlist,
+            }));
         if (context?.browser !== browser) {
+            context?.dispose();
             context = await McpContext.from(browser, logger, {
                 experimentalDevToolsDebugging: devtools,
                 experimentalIncludeAllPages: serverArgs.experimentalIncludeAllPages,
                 performanceCrux: serverArgs.performanceCrux,
+                allowList: allowlist,
+                blocklist: blocklist,
+                allowUnrestrictedPaths: serverArgs.allowUnrestrictedPaths,
+                // Surfaces a one-time note in the next response after a reconnect.
+                reconnected: context !== undefined,
             });
-            await updateRoots();
+            if (lastRoots === undefined) {
+                // Nothing listed yet, so this call has to wait – bounded, since it is
+                // holding the tool mutex, and a later background refresh still lands
+                await updateRoots(ROOTS_REQUEST_TIMEOUT);
+            }
+            else {
+                // Carry the known roots over and refresh out of band, so a reconnect
+                // never pays for a client round-trip
+                context.setRoots(lastRoots);
+                void updateRoots();
+            }
         }
         return context;
     }
-    async function restartBrowserWithoutOperaFlags() {
-        context?.dispose();
-        context = undefined;
-        browserHasOperaFlags = false;
-        await closeBrowserIfOpen();
-        // getContext() will relaunch without --disable-blink-features=AutomationControlled
-    }
-    async function restartBrowserForOpera() {
-        context?.dispose();
-        context = undefined;
-        browserHasOperaFlags = false;
-        await closeBrowserIfOpen();
-        const chromeArgs = [
-            '--disable-blink-features=AutomationControlled',
-            ...(serverArgs.chromeArg ?? []).map(String),
-        ];
-        if (serverArgs.proxyServer) {
-            chromeArgs.push(`--proxy-server=${serverArgs.proxyServer}`);
-        }
-        await ensureBrowserLaunched({
-            headless: serverArgs.headless,
-            executablePath: serverArgs.executablePath,
-            channel: serverArgs.channel,
-            isolated: serverArgs.isolated ?? false,
-            userDataDir: serverArgs.userDataDir,
-            logFile: options.logFile,
-            viewport: serverArgs.viewport,
-            chromeArgs,
-            ignoreDefaultChromeArgs: (serverArgs.ignoreDefaultChromeArg ?? []).map(String),
-            acceptInsecureCerts: serverArgs.acceptInsecureCerts,
-            devtools: serverArgs.experimentalDevtools ?? false,
-            enableExtensions: serverArgs.categoryExtensions,
-            viaCli: serverArgs.viaCli,
-        });
-        browserHasOperaFlags = true;
-    }
+    const operaHooks = createOperaToolHooks({
+        serverArgs,
+        logFile: options.logFile,
+        resetContext: () => {
+            context?.dispose();
+            context = undefined;
+        },
+    });
     const toolMutex = new Mutex();
     function registerTool(tool) {
-        if (tool.annotations.category === ToolCategory.EMULATION &&
-            serverArgs.categoryEmulation === false) {
-            return;
-        }
-        if (tool.annotations.category === ToolCategory.PERFORMANCE &&
-            serverArgs.categoryPerformance === false) {
-            return;
-        }
-        if (tool.annotations.category === ToolCategory.NETWORK &&
-            serverArgs.categoryNetwork === false) {
-            return;
-        }
-        if (tool.annotations.category === ToolCategory.EXTENSIONS &&
-            !serverArgs.categoryExtensions) {
-            return;
-        }
-        if (tool.annotations.category === ToolCategory.WEBMCP &&
-            !serverArgs.categoryExperimentalWebmcp) {
+        const toolHandler = new ToolHandler(tool, serverArgs, getContext, toolMutex, operaHooks);
+        if (!toolHandler.shouldRegister) {
             return;
         }
-        if (tool.annotations.category === ToolCategory.THIRD_PARTY &&
-            !serverArgs.categoryExperimentalThirdParty) {
-            return;
-        }
-        if (tool.annotations.conditions?.includes('experimentalVision') &&
-            !serverArgs.experimentalVision) {
-            return;
-        }
-        if (tool.annotations.conditions?.includes('experimentalInteropTools') &&
-            !serverArgs.experimentalInteropTools) {
-            return;
-        }
-        if (tool.annotations.conditions?.includes('experimentalScreencast') &&
-            !serverArgs.experimentalScreencast) {
-            return;
-        }
-        if (tool.annotations.conditions?.includes('experimentalMemory') &&
-            !serverArgs.experimentalMemory) {
-            return;
-        }
-        const schema = 'pageScoped' in tool &&
-            tool.pageScoped &&
-            serverArgs.experimentalPageIdRouting &&
-            !serverArgs.slim
-            ? { ...tool.schema, ...pageIdSchema }
-            : tool.schema;
         server.registerTool(tool.name, {
             description: tool.description,
-            inputSchema: schema,
+            inputSchema: toolHandler.registeredInputSchema,
             annotations: tool.annotations,
         }, async (params, extra) => {
-            const guard = tool.annotations.category === ToolCategory.OPERA
-                ? null
-                : await toolMutex.acquire();
-            const startTime = Date.now();
-            let success = false;
-            try {
-                const isLaunchMode = !serverArgs.browserUrl &&
-                    !serverArgs.wsEndpoint &&
-                    !serverArgs.autoConnect;
-                const needsOperaFlags = tool.name === 'opera_do' || tool.name === 'opera_research';
-                const browserConnected = getCurrentBrowser()?.connected ?? false;
-                if (isLaunchMode) {
-                    if (needsOperaFlags &&
-                        !(browserHasOperaFlags && browserConnected)) {
-                        await restartBrowserForOpera();
-                    }
-                    else if (!needsOperaFlags &&
-                        browserHasOperaFlags &&
-                        browserConnected) {
-                        await restartBrowserWithoutOperaFlags();
-                    }
-                }
-                logger(`${tool.name} request: ${JSON.stringify(params, null, '  ')}`);
-                const context = await getContext();
-                logger(`${tool.name} context: resolved`);
-                await context.detectOpenDevToolsWindows();
-                const logCallback = (message) => {
-                    // `logger` carries the MCP request ID so the opera-cli bridge can route
-                    // this chunk to the correct HTTP response (see bridge.ts requestLoggers).
-                    // `data` stays a plain string so non-bridge MCP hosts (Claude Desktop,
-                    // VS Code, etc.) continue to render it as readable text.
-                    void extra.sendNotification({
-                        method: 'notifications/message',
-                        params: {
-                            level: 'info',
-                            data: message,
-                            logger: String(extra.requestId),
-                        },
-                    });
-                };
-                const response = serverArgs.slim
-                    ? new SlimMcpResponse(serverArgs, logCallback)
-                    : new McpResponse(serverArgs, logCallback);
-                try {
-                    if ('pageScoped' in tool && tool.pageScoped) {
-                        const page = serverArgs.experimentalPageIdRouting &&
-                            params.pageId &&
-                            !serverArgs.slim
-                            ? context.getPageById(params.pageId)
-                            : context.getSelectedMcpPage();
-                        response.setPage(page);
-                        if (tool.blockedByDialog) {
-                            page.throwIfDialogOpen();
-                        }
-                        await tool.handler({
-                            params,
-                            page,
-                            signal: extra.signal,
-                        }, response, context);
-                    }
-                    else {
-                        await tool.handler(
-                        // @ts-expect-error types do not match.
-                        {
-                            params,
-                            signal: extra.signal,
-                        }, response, context);
-                    }
-                }
-                catch (err) {
-                    response.setError(err);
-                }
-                const { content, structuredContent } = await response.handle(tool.name, context);
-                const result = {
-                    content,
-                };
-                if (response.error) {
-                    result.isError = true;
-                }
-                success = true;
-                if (serverArgs.experimentalStructuredContent) {
-                    result.structuredContent = structuredContent;
-                }
-                return result;
-            }
-            catch (err) {
-                logger(`${tool.name} error:`, err, err?.stack);
-                let errorText = err && 'message' in err ? err.message : String(err);
-                if ('cause' in err && err.cause) {
-                    errorText += `\nCause: ${err.cause.message}`;
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: errorText,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            finally {
-                void clearcutLogger?.logToolInvocation({
-                    toolName: tool.name,
-                    params: params,
-                    schema: tool.schema,
-                    success,
-                    latencyMs: bucketizeLatency(Date.now() - startTime),
-                });
-                guard?.dispose();
-            }
+            return await toolHandler.handle(params, extra);
         });
     }
     const tools = createTools(serverArgs);
@@ -306,14 +172,17 @@ export async function createMcpServer(serverArgs, options) {
         registerTool(tool);
     }
     await loadIssueDescriptions();
-    return { server, clearcutLogger };
+    return { server };
 }
 export const logDisclaimers = (args) => {
-    console.error(`opera-devtools-mcp exposes content of the browser instance to the MCP clients allowing them to inspect,
-debug, and modify any data in the browser or DevTools.
-Avoid sharing sensitive or personal information that you do not want to share with MCP clients.`);
+    console.error(BROWSER_EXPOSURE_DISCLAIMER);
     if (!args.slim && args.performanceCrux) {
         console.error(`Performance tools may send trace URLs to the Google CrUX API to fetch real-user experience data. To disable, run with --no-performance-crux.`);
     }
+    if (showUsageStatisticsDisclaimer() && !args.slim && args.usageStatistics) {
+        console.error(`
+Google collects usage statistics to improve Chrome DevTools MCP. To opt-out, run with --no-usage-statistics.
+For more details, visit: https://github.com/ChromeDevTools/chrome-devtools-mcp#usage-statistics`);
+    }
 };
 //# sourceMappingURL=index.js.map

package/build/src/opera/branding.js

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2026 Opera Software AS.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Single source of truth for every product string that differs from upstream
+ * `chrome-devtools-mcp`.
+ *
+ * Upstream files reference these constants instead of hardcoding literals, so
+ * the merge seam for rebranding is one changed line per string rather than a
+ * forked copy of the file.
+ */
+/** npm package name. Doubles as the MCP server binary name. */
+export const PACKAGE_NAME = 'opera-devtools-mcp';
+/** MCP server binary / daemon app name, also used as `process.title`. */
+export const MCP_BIN_NAME = PACKAGE_NAME;
+/** CLI binary name, e.g. `opera-devtools start`. */
+export const CLI_BIN_NAME = 'opera-devtools';
+/** Human-readable product name used in log lines. */
+export const PRODUCT_NAME = 'Opera DevTools MCP Server';
+/** Public repository, referenced from help text and disclaimers. */
+export const REPO_URL = 'https://github.com/operasoftware/opera-devtools-mcp';
+/** Directory under `$HOME/.cache` holding the update-check snapshot. */
+export const CACHE_DIR_NAME = PACKAGE_NAME;
+/** Bin script the daemon spawns to run the MCP server. */
+export const INDEX_SCRIPT_NAME = `${MCP_BIN_NAME}.js`;
+/** Upstream reads `CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS`. */
+export const ENV_NO_USAGE_STATISTICS = 'OPERA_DEVTOOLS_NO_USAGE_STATISTICS';
+/** Upstream reads `CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS`. */
+export const ENV_NO_UPDATE_CHECKS = 'OPERA_DEVTOOLS_NO_UPDATE_CHECKS';
+/** Upstream reads `CHROME_DEVTOOLS_MCP_CRASH_ON_UNCAUGHT`. */
+export const ENV_CRASH_ON_UNCAUGHT = 'OPERA_DEVTOOLS_CRASH_ON_UNCAUGHT';
+//# sourceMappingURL=branding.js.map

package/build/src/opera/browserFlags.js

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2026 Opera Norway AS. All rights reserved.
+ *
+ * This file is an original work developed by Opera.
+ */
+import { closeBrowserIfOpen, ensureBrowserLaunched, getCurrentBrowser, } from '../browser.js';
+import { buildLaunchOptions } from './browserLaunch.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Opera's AI features refuse to run when the page reports itself as
+ * automation-controlled, so the browser has to be launched with this flag for
+ * them. It is deliberately NOT applied to every launch: it changes observable
+ * page behaviour, which would silently alter results for ordinary DevTools
+ * tools.
+ */
+export const OPERA_AUTOMATION_FLAGS = [
+    '--disable-blink-features=AutomationControlled',
+];
+/**
+ * Only the tools that drive Opera's agentic AI need the automation flags.
+ * `opera_chat`, `opera_make` and `opera_list_models` talk to the service worker
+ * directly and work without them.
+ */
+const TOOLS_REQUIRING_OPERA_FLAGS = new Set(['opera_do', 'opera_research']);
+export function toolRequiresOperaFlags(toolName) {
+    return TOOLS_REQUIRING_OPERA_FLAGS.has(toolName);
+}
+/**
+ * Tracks whether the currently running browser was launched with
+ * {@link OPERA_AUTOMATION_FLAGS}. Module-level rather than per-server because
+ * the browser itself is a module-level singleton in `../browser.ts`.
+ */
+let browserHasOperaFlags = false;
+export function browserWasLaunchedWithOperaFlags() {
+    return browserHasOperaFlags;
+}
+/** Test seam: forget what we believe about the current browser. */
+export function resetOperaFlagState() {
+    browserHasOperaFlags = false;
+}
+/**
+ * True when this server launched the browser itself. When the user attached to
+ * an existing browser we must never kill and relaunch it.
+ */
+function isLaunchMode(serverArgs) {
+    return (!serverArgs.browserUrl && !serverArgs.wsEndpoint && !serverArgs.autoConnect);
+}
+/**
+ * Makes sure the running browser has (or lacks) the Opera automation flags to
+ * match what `toolName` needs, relaunching it if not. No-op when we did not
+ * launch the browser ourselves, or when the flags already match.
+ */
+export async function ensureBrowserFlagsForTool(toolName, serverArgs, logFile, control, 
+// Injected so tests do not need a real browser singleton.
+deps = { closeBrowserIfOpen, ensureBrowserLaunched }) {
+    if (!isLaunchMode(serverArgs)) {
+        return;
+    }
+    const needsOperaFlags = toolRequiresOperaFlags(toolName);
+    const browserConnected = getCurrentBrowser()?.connected ?? false;
+    // A disconnected browser tells us nothing about the flags of the next one.
+    if (needsOperaFlags && browserHasOperaFlags && browserConnected) {
+        return;
+    }
+    if (!needsOperaFlags && !(browserHasOperaFlags && browserConnected)) {
+        return;
+    }
+    logger?.(`Relaunching browser ${needsOperaFlags ? 'with' : 'without'} Opera automation flags for ${toolName}`);
+    control.resetContext();
+    browserHasOperaFlags = false;
+    await deps.closeBrowserIfOpen();
+    if (needsOperaFlags) {
+        // Launch options come from the shared `buildLaunchOptions` so the relaunch
+        // applies exactly the same flags (including blocklist/allowlist and proxy)
+        // as the normal launch in `index.ts`, plus the automation flags.
+        await deps.ensureBrowserLaunched(buildLaunchOptions(serverArgs, logFile, {
+            extraChromeArgs: OPERA_AUTOMATION_FLAGS,
+        }));
+        browserHasOperaFlags = true;
+    }
+    // Otherwise leave the browser closed: getContext() relaunches it without the
+    // Opera flags on the next call.
+}
+//# sourceMappingURL=browserFlags.js.map

package/build/src/opera/browserLaunch.js

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2026 Opera Norway AS. All rights reserved.
+ *
+ * This file is an original work developed by Opera.
+ */
+/**
+ * Single source of truth for mapping parsed server args to
+ * `ensureBrowserLaunched` options. Used by the normal launch in `src/index.ts`
+ * (`getContext`) and by the Opera browser relaunch in `opera/browserFlags.ts`.
+ *
+ * `index.ts` and `browserFlags.ts` used to build these options independently,
+ * so a relaunch could quietly omit a launch flag (notably `blocklist` /
+ * `allowlist`) and the two could drift apart on an upstream intake. Keep the
+ * mapping here so the relaunch path always launches the browser exactly like
+ * the normal path does, plus whatever `extraChromeArgs` the caller adds.
+ */
+export function buildLaunchOptions(serverArgs, logFile = undefined, extra = {}) {
+    const chromeArgs = [
+        ...(extra.extraChromeArgs ?? []),
+        ...(serverArgs.chromeArg ?? []).map(String),
+    ];
+    if (serverArgs.proxyServer) {
+        chromeArgs.push(`--proxy-server=${serverArgs.proxyServer}`);
+    }
+    const blocklist = extra.blocklist ??
+        (serverArgs.blockedUrlPattern
+            ? serverArgs.blockedUrlPattern.map(String)
+            : undefined);
+    const allowlist = extra.allowlist ??
+        (serverArgs.allowedUrlPattern
+            ? serverArgs.allowedUrlPattern.map(String)
+            : undefined);
+    return {
+        headless: serverArgs.headless,
+        executablePath: serverArgs.executablePath,
+        channel: serverArgs.channel,
+        isolated: serverArgs.isolated ?? false,
+        userDataDir: serverArgs.userDataDir,
+        logFile,
+        viewport: serverArgs.viewport,
+        chromeArgs,
+        ignoreDefaultChromeArgs: (serverArgs.ignoreDefaultChromeArg ?? []).map(String),
+        acceptInsecureCerts: serverArgs.acceptInsecureCerts,
+        devtools: extra.devtools ?? serverArgs.experimentalDevtools ?? false,
+        enableExtensions: serverArgs.categoryExtensions,
+        viaCli: serverArgs.viaCli,
+        blocklist,
+        allowlist,
+    };
+}
+//# sourceMappingURL=browserLaunch.js.map

package/build/src/opera/policy.js

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2026 Opera Software AS.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Opera's behavioural deltas on top of upstream `chrome-devtools-mcp`.
+ *
+ * The fork does not collect usage statistics and does not send performance
+ * trace URLs to Google's CrUX API. Upstream defaults both to `true`; here they
+ * default to `false`, the help text is inverted accordingly, and the MCP
+ * server entry point additionally forces them off even if a flag asked for
+ * them.
+ */
+import { ENV_NO_USAGE_STATISTICS, MCP_BIN_NAME } from './branding.js';
+/** Upstream default is `true`. */
+export const USAGE_STATISTICS_DEFAULT = false;
+/** Upstream default is `true`. */
+export const PERFORMANCE_CRUX_DEFAULT = false;
+/** Inverted from upstream's "Set to false to disable ..." wording. */
+export const PERFORMANCE_CRUX_DESCRIPTION = 'Set to true to enable sending URLs from performance traces to CrUX API to get field performance data.';
+/** Inverted from upstream's "Set to false to opt-out ..." wording. */
+export const USAGE_STATISTICS_DESCRIPTION = `Set to true to opt-in to usage statistics collection. Google collects usage data to improve the tool, handled under the Google Privacy Policy (https://policies.google.com/privacy). This is independent from Chrome browser metrics. Disabled if \`${ENV_NO_USAGE_STATISTICS}\` or \`CI\` env variables are set.`;
+/**
+ * Hard-off switch applied by the MCP server entry point after argument
+ * parsing. Defaults alone are not enough: a client could pass
+ * `--usageStatistics` or `--performanceCrux` explicitly.
+ */
+export function enforceTelemetryPolicy(args) {
+    if (args.usageStatistics || args.performanceCrux) {
+        console.error('Warning: usage statistics or CrUX were enabled via flags — forcing off.');
+    }
+    args.usageStatistics = false;
+    args.performanceCrux = false;
+}
+/** Branded replacement for upstream's browser-exposure disclaimer. */
+export const BROWSER_EXPOSURE_DISCLAIMER = `${MCP_BIN_NAME} exposes content of the browser instance to the MCP clients allowing them to inspect,
+debug, and modify any data in the browser or DevTools.
+Avoid sharing sensitive or personal information that you do not want to share with MCP clients.`;
+/**
+ * Upstream prints a Google usage-statistics opt-out paragraph from
+ * `logDisclaimers`. Opera never collects them, so the paragraph is suppressed.
+ *
+ * A function rather than a `false` constant so that upstream's block in
+ * `src/index.ts` stays live code and merges untouched.
+ */
+export function showUsageStatisticsDisclaimer() {
+    return false;
+}
+//# sourceMappingURL=policy.js.map

package/build/src/opera/serviceWorkerRetry.js

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2026 Opera Norway AS. All rights reserved.
+ *
+ * This file is an original work developed by Opera.
+ */
+/**
+ * Opera's AI service worker may not be running yet when the first CDP command
+ * arrives, so dispatches are retried with a fixed backoff.
+ *
+ * Exposed as a mutable object so tests can drive the retry loop without waiting
+ * on real time. Faking timers is not a workable alternative here: sinon's fake
+ * clock replaces the globals `node:test` uses to schedule subtests, which
+ * silently drops whole suites from the run.
+ */
+export const serviceWorkerRetryPolicy = {
+    maxAttempts: 5,
+    delayMs: 2500,
+};
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+export async function withServiceWorkerRetry(fn) {
+    const { maxAttempts, delayMs } = serviceWorkerRetryPolicy;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            lastError = e;
+            if (attempt < maxAttempts - 1) {
+                await sleep(delayMs);
+            }
+        }
+    }
+    throw lastError;
+}
+//# sourceMappingURL=serviceWorkerRetry.js.map