chrome-devtools-mcp 1.1.0 → 1.2.0

package/build/src/index.js

@@ -43,7 +43,7 @@ export async function createMcpServer(serverArgs, options) {
             context?.setRoots(roots.roots);
         }
         catch (e) {
-            logger('Failed to list roots', e);
+            logger?.('Failed to list roots', e);
         }
     };
     server.server.oninitialized = () => {
@@ -66,6 +66,12 @@ export async function createMcpServer(serverArgs, options) {
             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,
@@ -77,6 +83,8 @@ export async function createMcpServer(serverArgs, options) {
                     : undefined,
                 userDataDir: serverArgs.userDataDir,
                 devtools,
+                blocklist,
+                allowlist,
             })
             : await ensureBrowserLaunched({
                 headless: serverArgs.headless,
@@ -92,12 +100,16 @@ export async function createMcpServer(serverArgs, options) {
                 devtools,
                 enableExtensions: serverArgs.categoryExtensions,
                 viaCli: serverArgs.viaCli,
+                blocklist,
+                allowlist,
             });
         if (context?.browser !== browser) {
             context = await McpContext.from(browser, logger, {
                 experimentalDevToolsDebugging: devtools,
                 experimentalIncludeAllPages: serverArgs.experimentalIncludeAllPages,
                 performanceCrux: serverArgs.performanceCrux,
+                hasNetworkBlockOrAllowlist: Boolean((blocklist && blocklist.length > 0) ||
+                    (allowlist && allowlist.length > 0)),
             });
             await updateRoots();
         }

package/build/src/telemetry/ClearcutLogger.js

@@ -136,7 +136,7 @@ export class ClearcutLogger {
             }
         }
         catch (err) {
-            logger('Error in logDailyActiveIfNeeded:', err);
+            logger?.('Error in logDailyActiveIfNeeded:', err);
         }
     }
     async logServerError(args) {

package/build/src/telemetry/WatchdogClient.js

@@ -35,10 +35,10 @@ export class WatchdogClient {
         });
         this.#childProcess.unref();
         this.#childProcess.on('error', err => {
-            logger('Watchdog process error:', err);
+            logger?.('Watchdog process error:', err);
         });
         this.#childProcess.on('exit', (code, signal) => {
-            logger(`Watchdog exited with code ${code} and signal ${signal}`);
+            logger?.(`Watchdog exited with code ${code} and signal ${signal}`);
         });
     }
     send(message) {
@@ -50,11 +50,11 @@ export class WatchdogClient {
                 this.#childProcess.stdin.write(line);
             }
             catch (err) {
-                logger('Failed to write to watchdog stdin', err);
+                logger?.('Failed to write to watchdog stdin', err);
             }
         }
         else {
-            logger('Watchdog stdin not available, dropping message');
+            logger?.('Watchdog stdin not available, dropping message');
         }
     }
 }

package/build/src/telemetry/persistence.js

@@ -45,7 +45,7 @@ export class FilePersistence {
             return JSON.parse(content);
         }
         catch (error) {
-            logger(`Failed to read telemetry state from ${filePath}:`, error);
+            logger?.(`Failed to read telemetry state from ${filePath}:`, error);
             void ClearcutLogger.get()?.logServerError({
                 errorCode: ErrorCode.ERROR_CODE_PERSISTENCE_FILE_READ_FAILED,
             });
@@ -62,7 +62,7 @@ export class FilePersistence {
         }
         catch (error) {
             // Ignore errors during state saving to avoid crashing the server
-            logger(`Failed to save telemetry state to ${filePath}:`, error);
+            logger?.(`Failed to save telemetry state to ${filePath}:`, error);
             void ClearcutLogger.get()?.logServerError({
                 errorCode: ErrorCode.ERROR_CODE_PERSISTENCE_FILE_SAVE_FAILED,
             });

package/build/src/telemetry/watchdog/ClearcutSender.js

@@ -48,7 +48,7 @@ export class ClearcutSender {
             app_version: this.#appVersion,
             os_type: this.#osType,
         };
-        logger('Enqueing telemetry event', JSON.stringify(eventToSend, null, 2));
+        logger?.('Enqueing telemetry event', JSON.stringify(eventToSend, null, 2));
         this.#addToBuffer(eventToSend);
         if (!this.#timerStarted) {
             this.#timerStarted = true;
@@ -69,10 +69,10 @@ export class ClearcutSender {
                 this.#finalFlush(),
                 new Promise(resolve => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS)),
             ]);
-            logger('Final flush completed');
+            logger?.('Final flush completed');
         }
         catch (error) {
-            logger('Final flush failed:', error);
+            logger?.('Final flush failed:', error);
         }
     }
     async #flush() {
@@ -97,7 +97,7 @@ export class ClearcutSender {
                 }
             }
             else if (result.isPermanentError) {
-                logger('Permanent error, dropped batch of', eventsToSend.length, 'events');
+                logger?.('Permanent error, dropped batch of', eventsToSend.length, 'events');
             }
             else {
                 // Transient error: Requeue events at the front of the buffer
@@ -108,7 +108,7 @@ export class ClearcutSender {
         catch (error) {
             // Safety catch for unexpected errors, requeue events
             this.#buffer = [...eventsToSend, ...this.#buffer];
-            logger('Flush failed unexpectedly:', error);
+            logger?.('Flush failed unexpectedly:', error);
         }
         finally {
             this.#isFlushing = false;
@@ -118,7 +118,7 @@ export class ClearcutSender {
     #addToBuffer(event) {
         if (this.#buffer.length >= MAX_BUFFER_SIZE) {
             this.#buffer.shift();
-            logger('Telemetry buffer overflow: dropped oldest event');
+            logger?.('Telemetry buffer overflow: dropped oldest event');
         }
         this.#buffer.push({
             event,
@@ -126,18 +126,18 @@ export class ClearcutSender {
         });
     }
     #scheduleFlush(delayMs) {
-        logger(`Scheduling flush in ${delayMs}`);
+        logger?.(`Scheduling flush in ${delayMs}`);
         if (this.#flushTimer) {
             clearTimeout(this.#flushTimer);
         }
         this.#flushTimer = setTimeout(() => {
             this.#flush().catch(err => {
-                logger('Flush error:', err);
+                logger?.('Flush error:', err);
             });
         }, delayMs);
     }
     async #sendBatch(events) {
-        logger(`Sending batch of ${events.length}`);
+        logger?.(`Sending batch of ${events.length}`);
         const requestBody = {
             log_source: LOG_SOURCE,
             request_time_ms: Date.now().toString(),
@@ -176,7 +176,7 @@ export class ClearcutSender {
             if (status >= 500 || status === 429) {
                 return { success: false };
             }
-            logger('Telemetry permanent error:', status);
+            logger?.('Telemetry permanent error:', status);
             return { success: false, isPermanentError: true };
         }
         catch {

package/build/src/telemetry/watchdog/main.js

@@ -65,7 +65,7 @@ function main() {
             process.exit(code);
         });
     };
-    logger('Watchdog started', JSON.stringify({
+    logger?.('Watchdog started', JSON.stringify({
         pid: process.pid,
         parentPid,
         version: appVersion,
@@ -84,15 +84,15 @@ function main() {
             return;
         }
         isShuttingDown = true;
-        logger(`Parent death detected (${reason}). Sending shutdown event...`);
+        logger?.(`Parent death detected (${reason}). Sending shutdown event...`);
         sender
             .sendShutdownEvent()
             .then(() => {
-            logger('Shutdown event sent. Exiting.');
+            logger?.('Shutdown event sent. Exiting.');
             exit(0);
         })
             .catch(err => {
-            logger('Failed to send shutdown event', err);
+            logger?.('Failed to send shutdown event', err);
             exit(1);
         });
     }
@@ -114,7 +114,7 @@ function main() {
             }
         }
         catch (err) {
-            logger('Failed to parse IPC message', err);
+            logger?.('Failed to parse IPC message', err);
         }
     });
 }

package/build/src/third_party/THIRD_PARTY_NOTICES

@@ -906,6 +906,36 @@ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 
+-------------------- DEPENDENCY DIVIDER --------------------
+
+Name: @toon-format/toon
+URL: https://toonformat.dev
+Version: 2.2.0
+License: MIT
+
+MIT License
+
+Copyright (c) 2025-PRESENT Johann Schopplich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
 -------------------- DEPENDENCY DIVIDER --------------------
 
 Name: chrome-devtools-frontend

package/build/src/third_party/bundled-packages.json

@@ -1,6 +1,7 @@
 {
   "@modelcontextprotocol/sdk": "1.29.0",
-  "chrome-devtools-frontend": "1.0.1632065",
+  "@toon-format/toon": "^2.2.0",
+  "chrome-devtools-frontend": "1.0.1641723",
   "core-js": "3.49.0",
   "debug": "4.4.3",
   "lighthouse": "13.3.0",

package/build/src/third_party/devtools-formatter-worker.js

@@ -2648,6 +2648,7 @@ var ExperimentName;
     ExperimentName["USE_SOURCE_MAP_SCOPES"] = "use-source-map-scopes";
     ExperimentName["DURABLE_MESSAGES"] = "durable-messages";
     ExperimentName["JPEG_XL"] = "jpeg-xl";
+    ExperimentName["PLUS_BUTTON"] = "plus-button";
 })(ExperimentName || (ExperimentName = {}));
 
 // Copyright 2016 The Chromium Authors

package/build/src/third_party/devtools-heap-snapshot-worker.js

@@ -2843,6 +2843,7 @@ var ExperimentName;
     ExperimentName["USE_SOURCE_MAP_SCOPES"] = "use-source-map-scopes";
     ExperimentName["DURABLE_MESSAGES"] = "durable-messages";
     ExperimentName["JPEG_XL"] = "jpeg-xl";
+    ExperimentName["PLUS_BUTTON"] = "plus-button";
 })(ExperimentName || (ExperimentName = {}));
 
 // Copyright 2021 The Chromium Authors
@@ -5992,6 +5993,9 @@ class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     ignoreNodeInRetainersView(nodeIndex) {
         return this.callMethodPromise('ignoreNodeInRetainersView', nodeIndex);
     }
+    getRetainingPaths(nodeIndex, maxDepth, maxNodes, maxSiblings) {
+        return this.callMethodPromise('getRetainingPaths', nodeIndex, maxDepth, maxNodes, maxSiblings);
+    }
     unignoreNodeInRetainersView(nodeIndex) {
         return this.callMethodPromise('unignoreNodeInRetainersView', nodeIndex);
     }
@@ -8359,6 +8363,109 @@ class HeapSnapshot {
         const indexProvider = new HeapSnapshotRetainerEdgeIndexProvider(this);
         return new HeapSnapshotEdgesProvider(this, filter, node.retainers(), indexProvider);
     }
+    getRetainingPaths(nodeIndex, maxDepth = 30, maxNodes = 5000, maxSiblings = 100) {
+        const { nodeFieldCount, firstRetainerIndex, retainingNodes, retainingEdges, edgeTypeOffset, edgeWeakType, containmentEdges } = this;
+        const distances = this.#nodeDistancesForRetainersView ?? this.nodeDistances;
+        let traversedNodesCount = 0;
+        const visiting = new Set();
+        const visited = new Map();
+        const rootDistance = 2;
+        const limitsReached = {};
+        const buildForest = (currentIndex, currentDepth) => {
+            traversedNodesCount++;
+            if (traversedNodesCount > maxNodes) {
+                limitsReached.nodes = true;
+                return [];
+            }
+            if (currentDepth >= maxDepth) {
+                limitsReached.depth = true;
+                return [];
+            }
+            const ordinal = currentIndex / nodeFieldCount;
+            const currentDistance = distances[ordinal];
+            if (currentDistance <= rootDistance) {
+                return [];
+            }
+            if (visiting.has(currentIndex)) {
+                return [];
+            }
+            const cachedDepth = visited.get(currentIndex);
+            if (cachedDepth !== undefined) {
+                if (currentDepth >= cachedDepth) {
+                    return [];
+                }
+            }
+            visiting.add(currentIndex);
+            const beginRetainerIndex = firstRetainerIndex[ordinal];
+            const endRetainerIndex = firstRetainerIndex[ordinal + 1];
+            const retainers = [];
+            for (let retainerIndex = beginRetainerIndex; retainerIndex < endRetainerIndex; ++retainerIndex) {
+                const retainerNodeIndex = retainingNodes[retainerIndex];
+                const retainerNodeOrdinal = retainerNodeIndex / nodeFieldCount;
+                const dist = distances[retainerNodeOrdinal];
+                const globalEdgeIndex = retainingEdges[retainerIndex];
+                if (this.isEdgeIgnoredInRetainersView(globalEdgeIndex)) {
+                    continue;
+                }
+                const edgeType = containmentEdges.getValue(globalEdgeIndex + edgeTypeOffset);
+                if (edgeType === edgeWeakType) {
+                    continue;
+                }
+                if (dist >= 0) {
+                    const remainingDepth = maxDepth - currentDepth;
+                    const neededDepth = dist - rootDistance;
+                    if (neededDepth < remainingDepth) {
+                        retainers.push({ retainerIndex, dist, nodeIndex: retainerNodeIndex });
+                    }
+                    else {
+                        limitsReached.depth = true;
+                    }
+                }
+            }
+            retainers.sort((a, b) => a.dist - b.dist);
+            const length = Math.min(retainers.length, maxSiblings);
+            if (retainers.length > maxSiblings) {
+                limitsReached.siblings = true;
+            }
+            const forest = [];
+            for (let i = 0; i < length; i++) {
+                const retainer = retainers[i];
+                const edge = this.createRetainingEdge(retainer.retainerIndex);
+                const globalEdgeIndex = retainingEdges[retainer.retainerIndex];
+                const isRoot = retainer.dist === rootDistance;
+                let children = [];
+                if (isRoot) {
+                    traversedNodesCount++;
+                    if (traversedNodesCount > maxNodes) {
+                        limitsReached.nodes = true;
+                        break;
+                    }
+                }
+                else {
+                    children = buildForest(retainer.nodeIndex, currentDepth + 1);
+                    if (children.length === 0) {
+                        continue;
+                    }
+                }
+                const retainerNode = this.createNode(retainer.nodeIndex);
+                forest.push({
+                    edgeIndex: globalEdgeIndex,
+                    edgeName: edge.name(),
+                    edgeType: edge.type(),
+                    nodeId: retainerNode.id(),
+                    nodeIndex: retainer.nodeIndex,
+                    nodeName: retainerNode.name(),
+                    distance: retainer.dist,
+                    children,
+                });
+            }
+            visiting.delete(currentIndex);
+            visited.set(currentIndex, currentDepth);
+            return forest;
+        };
+        const paths = buildForest(nodeIndex, 0);
+        return { paths, limitsReached };
+    }
     createAddedNodesProvider(baseSnapshotId, classKey) {
         const snapshotDiff = this.#snapshotDiffs[baseSnapshotId];
         const diffForClass = snapshotDiff[classKey];