brave-mcp 0.4.0 → 1.2.0

package/build/src/McpContext.js

@@ -4,17 +4,19 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import fs from 'node:fs/promises';
+import fsPromises from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { UniverseManager } from './DevtoolsUtils.js';
+import { overrideDevToolsGlobals, UniverseManager, } from './devtools/DevtoolsUtils.js';
 import { HeapSnapshotManager } from './HeapSnapshotManager.js';
 import { McpPage } from './McpPage.js';
 import { NetworkCollector, ConsoleCollector, } from './PageCollector.js';
+import { ServiceWorkerConsoleCollector } from './ServiceWorkerCollector.js';
 import { Locator, PredefinedNetworkConditions, } from './third_party/index.js';
 import { listPages } from './tools/pages.js';
 import { CLOSE_PAGE_ERROR } from './tools/ToolDefinition.js';
-import { ensureExtension, getTempFilePath } from './utils/files.js';
+import { ensureExtension, getTempFilePath, resolveCanonicalPath, } from './utils/files.js';
 import { getNetworkMultiplierFromString } from './WaitForHelper.js';
 const DEFAULT_TIMEOUT = 5_000;
 const NAVIGATION_TIMEOUT = 10_000;
@@ -32,6 +34,7 @@ export class McpContext {
     #networkCollector;
     #consoleCollector;
     #devtoolsUniverseManager;
+    #serviceWorkerConsoleCollector;
     #isRunningTrace = false;
     #screenRecorderData = null;
     #nextPageId = 1;
@@ -44,6 +47,7 @@ export class McpContext {
     #heapSnapshotManager = new HeapSnapshotManager();
     #roots = undefined;
     constructor(browser, logger, options, locatorClass) {
+        overrideDevToolsGlobals();
         this.browser = browser;
         this.logger = logger;
         this.#locatorClass = locatorClass;
@@ -62,19 +66,22 @@ export class McpContext {
                 },
             };
         });
+        this.#serviceWorkerConsoleCollector = new ServiceWorkerConsoleCollector(this.browser);
         this.#devtoolsUniverseManager = new UniverseManager(this.browser);
     }
     async #init() {
         const pages = await this.createPagesSnapshot();
-        await this.createExtensionServiceWorkersSnapshot();
+        const workers = await this.createExtensionServiceWorkersSnapshot();
         await this.#networkCollector.init(pages);
         await this.#consoleCollector.init(pages);
         await this.#devtoolsUniverseManager.init(pages);
+        await this.#serviceWorkerConsoleCollector.init(workers);
     }
     dispose() {
         this.#networkCollector.dispose();
         this.#consoleCollector.dispose();
         this.#devtoolsUniverseManager.dispose();
+        this.#serviceWorkerConsoleCollector.dispose();
         for (const mcpPage of this.#mcpPages.values()) {
             mcpPage.dispose();
         }
@@ -106,7 +113,7 @@ export class McpContext {
     setRoots(roots) {
         this.#roots = roots;
     }
-    validatePath(filePath) {
+    async validatePath(filePath) {
         if (filePath === undefined) {
             return;
         }
@@ -114,19 +121,40 @@ export class McpContext {
         if (roots === undefined) {
             return;
         }
-        const absolutePath = path.resolve(filePath);
+        let canonicalPath;
+        try {
+            canonicalPath = await resolveCanonicalPath(filePath);
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            console.error(`[MCP Context] Error resolving real path for ${filePath}: ${errMsg}`);
+            throw new Error(`Access denied: Cannot resolve base path for ${filePath}.`);
+        }
+        let allowed = false;
         for (const root of roots) {
-            const rootPath = path.resolve(fileURLToPath(root.uri));
-            if (absolutePath === rootPath ||
-                absolutePath.startsWith(rootPath + path.sep)) {
-                return;
+            try {
+                const rootPathUri = root.uri;
+                const rootPath = path.resolve(fileURLToPath(rootPathUri));
+                const canonicalRoot = await fsPromises.realpath(rootPath);
+                if (canonicalPath === canonicalRoot ||
+                    canonicalPath.startsWith(canonicalRoot + path.sep)) {
+                    allowed = true;
+                    break;
+                }
+            }
+            catch (rootErr) {
+                const errMsg = rootErr instanceof Error ? rootErr.message : String(rootErr);
+                console.warn(`[MCP Context] Could not resolve configured root ${root.uri}: ${errMsg}`);
+                // Skip this root if it cannot be resolved.
             }
         }
-        throw new Error(`Access denied: path ${filePath} is not within any of the workspace roots ${JSON.stringify(roots)}.`);
+        if (!allowed) {
+            throw new Error(`Access denied: path ${filePath} (canonical: ${canonicalPath}) is not within any of the configured workspace roots.`);
+        }
     }
     resolveCdpRequestId(page, cdpRequestId) {
         if (!cdpRequestId) {
-            this.logger('no network request');
+            this.logger?.('no network request');
             return;
         }
         const request = this.#networkCollector.find(page.pptrPage, request => {
@@ -134,7 +162,7 @@ export class McpContext {
             return request.id === cdpRequestId;
         });
         if (!request) {
-            this.logger('no network request for ' + cdpRequestId);
+            this.logger?.('no network request for ' + cdpRequestId);
             return;
         }
         return this.#networkCollector.getIdForResource(request);
@@ -195,7 +223,13 @@ export class McpContext {
         const page = targetPage ?? this.getSelectedPptrPage();
         const mcpPage = this.#getMcpPage(page);
         const newSettings = { ...mcpPage.emulationSettings };
-        if (!options.networkConditions) {
+        // Skip network emulation if blocklist/allowlist is configured, as it conflicts with blocking rules in Puppeteer.
+        if (this.#options.hasNetworkBlockOrAllowlist) {
+            if (options.networkConditions !== undefined) {
+                throw new Error('Network throttling is not supported when network blocking (allowlist/blocklist) is configured.');
+            }
+        }
+        else if (!options.networkConditions) {
             await page.emulateNetworkConditions(null);
             delete newSettings.networkConditions;
         }
@@ -213,12 +247,23 @@ export class McpContext {
             await page.emulateNetworkConditions(networkCondition);
             newSettings.networkConditions = options.networkConditions;
         }
+        const secondarySession = this.getDevToolsUniverse(mcpPage)?.session;
         if (!options.cpuThrottlingRate) {
             await page.emulateCPUThrottling(1);
+            if (secondarySession) {
+                await secondarySession.send('Emulation.setCPUThrottlingRate', {
+                    rate: 1,
+                });
+            }
             delete newSettings.cpuThrottlingRate;
         }
         else {
             await page.emulateCPUThrottling(options.cpuThrottlingRate);
+            if (secondarySession) {
+                await secondarySession.send('Emulation.setCPUThrottlingRate', {
+                    rate: options.cpuThrottlingRate,
+                });
+            }
             newSettings.cpuThrottlingRate = options.cpuThrottlingRate;
         }
         if (!options.geolocation) {
@@ -250,7 +295,6 @@ export class McpContext {
             newSettings.colorScheme = options.colorScheme;
         }
         if (!options.viewport) {
-            await page.setViewport(null);
             delete newSettings.viewport;
         }
         else {
@@ -260,14 +304,22 @@ export class McpContext {
                 hasTouch: false,
                 isLandscape: false,
             };
-            const viewport = { ...defaults, ...options.viewport };
-            await page.setViewport(viewport);
-            newSettings.viewport = viewport;
+            newSettings.viewport = { ...defaults, ...options.viewport };
+        }
+        if (options.extraHttpHeaders !== undefined) {
+            await page.setExtraHTTPHeaders(options.extraHttpHeaders);
+            newSettings.extraHttpHeaders = options.extraHttpHeaders;
+            if (Object.keys(options.extraHttpHeaders).length === 0) {
+                delete newSettings.extraHttpHeaders;
+            }
         }
         mcpPage.emulationSettings = Object.keys(newSettings).length
             ? newSettings
             : {};
         this.#updateSelectedPageTimeouts();
+        // This should happen after updating the page timeouts.
+        // Setting the viewport can trigger a reload which we don't want to timeout.
+        await page.setViewport(newSettings.viewport ?? null);
     }
     setIsRunningPerformanceTrace(x) {
         this.#isRunningTrace = x;
@@ -333,9 +385,9 @@ export class McpContext {
         page.pptrPage.setDefaultTimeout(DEFAULT_TIMEOUT * cpuMultiplier);
         // 10sec should be enough for the load event to be emitted during
         // navigations.
-        // Increased in case we throttle the network requests
+        // Increased in case we throttle the network requests or the CPU
         const networkMultiplier = getNetworkMultiplierFromString(page.networkConditions);
-        page.pptrPage.setDefaultNavigationTimeout(NAVIGATION_TIMEOUT * networkMultiplier);
+        page.pptrPage.setDefaultNavigationTimeout(NAVIGATION_TIMEOUT * networkMultiplier * cpuMultiplier);
     }
     // Linear scan over per-page snapshots. The page count is small (typically
     // 2-10) so a reverse index isn't worthwhile given the uid-reuse lifecycle
@@ -372,6 +424,9 @@ export class McpContext {
         });
         return this.#extensionServiceWorkers;
     }
+    getServiceWorkerConsoleData(extensionId) {
+        return this.#serviceWorkerConsoleCollector.getData(extensionId);
+    }
     async createPagesSnapshot() {
         const { pages: allPages, isolatedContextNames } = await this.#getAllPages();
         for (const page of allPages) {
@@ -381,7 +436,7 @@ export class McpContext {
                 this.#mcpPages.set(page, mcpPage);
                 // We emulate a focused page for all pages to support multi-agent workflows.
                 void page.emulateFocusedPage(true).catch(error => {
-                    this.logger('Error turning on focused page emulation', error);
+                    this.logger?.('Error turning on focused page emulation', error);
                 });
             }
             mcpPage.isolatedContextName = isolatedContextNames.get(page);
@@ -427,7 +482,7 @@ export class McpContext {
                         this.#extensionPages.set(target, page);
                     }
                     catch (e) {
-                        this.logger('Failed to get page for extension target', e);
+                        this.logger?.('Failed to get page for extension target', e);
                     }
                 }
             }
@@ -462,7 +517,7 @@ export class McpContext {
         return { pages: allPages, isolatedContextNames };
     }
     async detectOpenDevToolsWindows() {
-        this.logger('Detecting open DevTools windows');
+        this.logger?.('Detecting open DevTools windows');
         const { pages } = await this.#getAllPages();
         await Promise.all(pages.map(async (page) => {
             const mcpPage = this.#mcpPages.get(page);
@@ -499,7 +554,7 @@ export class McpContext {
     }
     async saveTemporaryFile(data, filename) {
         const filepath = await getTempFilePath(filename);
-        this.validatePath(filepath);
+        await this.validatePath(filepath);
         try {
             await fs.writeFile(filepath, data);
         }
@@ -509,7 +564,7 @@ export class McpContext {
         return { filepath };
     }
     async saveFile(data, clientProvidedFilePath, extension) {
-        this.validatePath(clientProvidedFilePath);
+        await this.validatePath(clientProvidedFilePath);
         try {
             const filePath = ensureExtension(path.resolve(clientProvidedFilePath), extension);
             await fs.mkdir(path.dirname(filePath), { recursive: true });
@@ -517,7 +572,7 @@ export class McpContext {
             return { filename: filePath };
         }
         catch (err) {
-            this.logger(err);
+            this.logger?.(err);
             throw new Error('Could not save a file', { cause: err });
         }
     }
@@ -562,7 +617,6 @@ export class McpContext {
         await this.#networkCollector.init(pages);
     }
     async installExtension(extensionPath) {
-        this.validatePath(extensionPath);
         const id = await this.browser.installExtension(extensionPath);
         return id;
     }
@@ -586,20 +640,28 @@ export class McpContext {
         return pptrExtensions.get(id);
     }
     async getHeapSnapshotAggregates(filePath) {
-        this.validatePath(filePath);
         return await this.#heapSnapshotManager.getAggregates(filePath);
     }
     async getHeapSnapshotStats(filePath) {
-        this.validatePath(filePath);
         return await this.#heapSnapshotManager.getStats(filePath);
     }
     async getHeapSnapshotStaticData(filePath) {
-        this.validatePath(filePath);
         return await this.#heapSnapshotManager.getStaticData(filePath);
     }
-    async getHeapSnapshotNodesByUid(filePath, uid) {
-        this.validatePath(filePath);
-        return await this.#heapSnapshotManager.getNodesByUid(filePath, uid);
+    async getHeapSnapshotNodesById(filePath, id) {
+        return await this.#heapSnapshotManager.getNodesById(filePath, id);
+    }
+    async getHeapSnapshotRetainers(filePath, nodeId) {
+        return await this.#heapSnapshotManager.getRetainers(filePath, nodeId);
+    }
+    async closeHeapSnapshot(filePath) {
+        return this.#heapSnapshotManager.dispose(filePath);
+    }
+    hasHeapSnapshots() {
+        return this.#heapSnapshotManager.hasSnapshots();
+    }
+    async getHeapSnapshotRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings) {
+        return await this.#heapSnapshotManager.getRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings);
     }
 }
 //# sourceMappingURL=McpContext.js.map

package/build/src/McpPage.js

@@ -30,7 +30,7 @@ export class McpPage {
     // Dialog
     #dialog;
     #dialogHandler;
-    thirdPartyDeveloperTools;
+    thirdPartyDeveloperTools = [];
     constructor(page, id) {
         this.pptrPage = page;
         this.id = id;
@@ -194,18 +194,18 @@ export class McpPage {
             for (const handle of oldHandles) {
                 await handle
                     .dispose()
-                    .catch(e => logger('Failed to dispose old handle', e));
+                    .catch(e => logger?.('Failed to dispose old handle', e));
             }
         }
         const cdpElementIds = await Promise.all(elementHandles.map(async (elementHandle, index) => {
             const backendNodeId = await elementHandle.backendNodeId();
             if (!backendNodeId) {
-                logger(`No backendNodeId for stashed DOM element with index ${index}`);
+                logger?.(`No backendNodeId for stashed DOM element with index ${index}`);
                 return `stashed-${index}`;
             }
             const cdpElementId = this.resolveCdpElementId(backendNodeId);
             if (!cdpElementId) {
-                logger(`Could not get cdpElementId for backend node ${backendNodeId}`);
+                logger?.(`Could not get cdpElementId for backend node ${backendNodeId}`);
                 return `stashed-${index}`;
             }
             return cdpElementId;
@@ -263,12 +263,12 @@ export class McpPage {
     }
     resolveCdpElementId(cdpBackendNodeId) {
         if (!cdpBackendNodeId) {
-            logger('no cdpBackendNodeId');
+            logger?.('no cdpBackendNodeId');
             return;
         }
         const snapshot = this.textSnapshot;
         if (!snapshot) {
-            logger('no text snapshot');
+            logger?.('no text snapshot');
             return;
         }
         // TODO: index by backendNodeId instead.
@@ -286,10 +286,10 @@ export class McpPage {
     }
     async getDevToolsData() {
         try {
-            logger('Getting DevTools UI data');
+            logger?.('Getting DevTools UI data');
             const devtoolsPage = this.devToolsPage;
             if (!devtoolsPage) {
-                logger('No DevTools page detected');
+                logger?.('No DevTools page detected');
                 return {};
             }
             const { cdpRequestId, cdpBackendNodeId } = await devtoolsPage.evaluate(async () => {
@@ -307,7 +307,7 @@ export class McpPage {
             return { cdpBackendNodeId, cdpRequestId };
         }
         catch (err) {
-            logger('error getting devtools data', err);
+            logger?.('error getting devtools data', err);
         }
         return {};
     }