chrome-devtools-mcp 0.23.0 → 0.24.0

package/build/src/DevToolsConnectionAdapter.js

@@ -67,3 +67,4 @@ export class PuppeteerDevToolsConnection {
         }
     }
 }
+//# sourceMappingURL=DevToolsConnectionAdapter.js.map

package/build/src/DevtoolsUtils.js

@@ -292,3 +292,4 @@ async function waitForScript(model, scriptId, signal) {
         });
     }
 }
+//# sourceMappingURL=DevtoolsUtils.js.map

package/build/src/HeapSnapshotManager.js

@@ -56,6 +56,17 @@ export class HeapSnapshotManager {
         }
         return uid;
     }
+    async getNodesByUid(filePath, uid) {
+        const snapshot = await this.getSnapshot(filePath);
+        const filter = new DevTools.HeapSnapshotModel.HeapSnapshotModel.NodeFilter();
+        const className = await this.resolveClassKeyFromUid(filePath, uid);
+        if (!className) {
+            throw new Error(`Class with UID ${uid} not found in heap snapshot`);
+        }
+        const provider = snapshot.createNodesProviderForClass(className, filter);
+        const range = await provider.serializeItemsRange(0, 1);
+        return await provider.serializeItemsRange(0, range.totalLength);
+    }
     #getCachedSnapshot(filePath) {
         const absolutePath = path.resolve(filePath);
         const cached = this.#snapshots.get(absolutePath);
@@ -64,6 +75,10 @@ export class HeapSnapshotManager {
         }
         return cached;
     }
+    async resolveClassKeyFromUid(filePath, uid) {
+        const cached = this.#getCachedSnapshot(filePath);
+        return cached.uidToClassKey.get(uid);
+    }
     async #loadSnapshot(absolutePath) {
         const workerProxy = new DevTools.HeapSnapshotModel.HeapSnapshotProxy.HeapSnapshotWorkerProxy(() => {
             /* noop */
@@ -92,3 +107,4 @@ export class HeapSnapshotManager {
         }
     }
 }
+//# sourceMappingURL=HeapSnapshotManager.js.map

package/build/src/McpContext.js

@@ -4,16 +4,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import fs 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 { HeapSnapshotManager } from './HeapSnapshotManager.js';
 import { McpPage } from './McpPage.js';
 import { NetworkCollector, ConsoleCollector, } from './PageCollector.js';
-import { Locator } from './third_party/index.js';
-import { PredefinedNetworkConditions } from './third_party/index.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, saveTemporaryFile } from './utils/files.js';
+import { ensureExtension, getTempFilePath } from './utils/files.js';
 import { getNetworkMultiplierFromString } from './WaitForHelper.js';
 const DEFAULT_TIMEOUT = 5_000;
 const NAVIGATION_TIMEOUT = 10_000;
@@ -41,6 +42,7 @@ export class McpContext {
     #locatorClass;
     #options;
     #heapSnapshotManager = new HeapSnapshotManager();
+    #roots = undefined;
     constructor(browser, logger, options, locatorClass) {
         this.browser = browser;
         this.logger = logger;
@@ -89,6 +91,39 @@ export class McpContext {
         await context.#init();
         return context;
     }
+    roots() {
+        if (this.#roots === undefined) {
+            return undefined;
+        }
+        return [
+            ...this.#roots,
+            {
+                uri: pathToFileURL(os.tmpdir()).href,
+                name: 'temp',
+            },
+        ];
+    }
+    setRoots(roots) {
+        this.#roots = roots;
+    }
+    validatePath(filePath) {
+        if (filePath === undefined) {
+            return;
+        }
+        const roots = this.roots();
+        if (roots === undefined) {
+            return;
+        }
+        const absolutePath = path.resolve(filePath);
+        for (const root of roots) {
+            const rootPath = path.resolve(fileURLToPath(root.uri));
+            if (absolutePath === rootPath ||
+                absolutePath.startsWith(rootPath + path.sep)) {
+                return;
+            }
+        }
+        throw new Error(`Access denied: path ${filePath} is not within any of the workspace roots ${JSON.stringify(roots)}.`);
+    }
     resolveCdpRequestId(page, cdpRequestId) {
         if (!cdpRequestId) {
             this.logger('no network request');
@@ -463,9 +498,18 @@ export class McpContext {
         return this.#mcpPages.get(page)?.isolatedContextName;
     }
     async saveTemporaryFile(data, filename) {
-        return await saveTemporaryFile(data, filename);
+        const filepath = await getTempFilePath(filename);
+        this.validatePath(filepath);
+        try {
+            await fs.writeFile(filepath, data);
+        }
+        catch (err) {
+            throw new Error('Could not save a file', { cause: err });
+        }
+        return { filepath };
     }
     async saveFile(data, clientProvidedFilePath, extension) {
+        this.validatePath(clientProvidedFilePath);
         try {
             const filePath = ensureExtension(path.resolve(clientProvidedFilePath), extension);
             await fs.mkdir(path.dirname(filePath), { recursive: true });
@@ -518,6 +562,7 @@ export class McpContext {
         await this.#networkCollector.init(pages);
     }
     async installExtension(extensionPath) {
+        this.validatePath(extensionPath);
         const id = await this.browser.installExtension(extensionPath);
         return id;
     }
@@ -541,12 +586,20 @@ 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);
+    }
 }
+//# sourceMappingURL=McpContext.js.map

package/build/src/McpPage.js

@@ -48,6 +48,11 @@ export class McpPage {
     clearDialog() {
         this.#dialog = undefined;
     }
+    throwIfDialogOpen() {
+        if (this.#dialog) {
+            throw new Error(`A dialog is open (${this.#dialog.type()}: ${this.#dialog.message()}).`);
+        }
+    }
     getInPageTools() {
         return this.inPageTools;
     }
@@ -307,3 +312,4 @@ export class McpPage {
         return {};
     }
 }
+//# sourceMappingURL=McpPage.js.map

package/build/src/McpResponse.js

@@ -5,6 +5,7 @@
  */
 import { ConsoleFormatter } from './formatters/ConsoleFormatter.js';
 import { HeapSnapshotFormatter } from './formatters/HeapSnapshotFormatter.js';
+import { isNodeLike } from './formatters/HeapSnapshotFormatter.js';
 import { IssueFormatter } from './formatters/IssueFormatter.js';
 import { NetworkFormatter } from './formatters/NetworkFormatter.js';
 import { SnapshotFormatter } from './formatters/SnapshotFormatter.js';
@@ -131,6 +132,7 @@ export class McpResponse {
     #args;
     #page;
     #redactNetworkHeaders = true;
+    #error;
     constructor(args) {
         this.#args = args;
     }
@@ -162,7 +164,7 @@ export class McpResponse {
         this.#listExtensions = true;
     }
     setListInPageTools() {
-        if (this.#args.categoryInPageTools) {
+        if (this.#args.categoryExperimentalInPage) {
             this.#listInPageTools = true;
         }
     }
@@ -204,6 +206,9 @@ export class McpResponse {
             includePreservedMessages: options?.includePreservedMessages,
         };
     }
+    setError(error) {
+        this.#error = error;
+    }
     attachNetworkRequest(reqId, options) {
         this.#attachedNetworkRequestId = reqId;
         this.#attachedNetworkRequestOptions = options;
@@ -254,6 +259,9 @@ export class McpResponse {
     get consoleMessagesTypes() {
         return this.#consoleDataOptions?.types;
     }
+    get error() {
+        return this.#error;
+    }
     appendResponseLine(value) {
         this.#textResponseLines.push(value);
     }
@@ -273,6 +281,14 @@ export class McpResponse {
             staticData,
         };
     }
+    setHeapSnapshotNodes(nodes, options) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            nodes,
+            pagination: options,
+        };
+    }
     attachImage(value) {
         this.#images.push(value);
     }
@@ -455,6 +471,7 @@ export class McpResponse {
             lighthouseResult: this.#attachedLighthouseResult,
             inPageTools,
             webmcpTools,
+            errorMessage: this.#error?.message,
         });
     }
     format(toolName, context, data) {
@@ -645,6 +662,17 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 response.push(formatter.toString());
                 structuredContent.heapSnapshotData = formatter.toJSON();
             }
+            const nodes = this.#heapSnapshotOptions.nodes;
+            if (nodes) {
+                const sortedItems = nodes.items
+                    .filter(isNodeLike)
+                    .sort((a, b) => b.retainedSize - a.retainedSize);
+                const paginationData = this.#dataWithPagination(sortedItems, this.#heapSnapshotOptions.pagination);
+                response.push(HeapSnapshotFormatter.formatNodes(paginationData.items));
+                structuredContent.pagination = paginationData.pagination;
+                response.push(...paginationData.info);
+                structuredContent.heapSnapshotNodes = paginationData.items;
+            }
         }
         if (data.detailedNetworkRequest) {
             response.push(data.detailedNetworkRequest.toStringDetailed());
@@ -733,16 +761,21 @@ Call ${handleDialog.name} to handle it before continuing.`);
             const messages = data.consoleMessages ?? [];
             response.push('## Console messages');
             if (messages.length) {
-                const paginationData = this.#dataWithPagination(messages, this.#consoleDataOptions.pagination);
+                const grouped = ConsoleFormatter.groupConsecutive(messages);
+                const paginationData = this.#dataWithPagination(grouped, this.#consoleDataOptions.pagination);
                 structuredContent.pagination = paginationData.pagination;
                 response.push(...paginationData.info);
-                response.push(...paginationData.items.map(message => message.toString()));
-                structuredContent.consoleMessages = paginationData.items.map(message => message.toJSON());
+                response.push(...paginationData.items.map(item => item.toString()));
+                structuredContent.consoleMessages = paginationData.items.map(item => item.toJSON());
             }
             else {
                 response.push('<no console messages found>');
             }
         }
+        if (data.errorMessage) {
+            response.push(`Error: ${data.errorMessage}`);
+            structuredContent.errorMessage = data.errorMessage;
+        }
         const text = {
             type: 'text',
             text: response.join('\n'),
@@ -804,3 +837,4 @@ function createStructuredPage(page, context) {
     }
     return entry;
 }
+//# sourceMappingURL=McpResponse.js.map

package/build/src/Mutex.js

@@ -35,3 +35,4 @@ export class Mutex {
         resolve();
     }
 }
+//# sourceMappingURL=Mutex.js.map

package/build/src/PageCollector.js

@@ -294,3 +294,4 @@ export class NetworkCollector extends PageCollector {
         navigations.splice(this.maxNavigationSaved);
     }
 }
+//# sourceMappingURL=PageCollector.js.map

package/build/src/SlimMcpResponse.js

@@ -16,3 +16,4 @@ export class SlimMcpResponse extends McpResponse {
         };
     }
 }
+//# sourceMappingURL=SlimMcpResponse.js.map

package/build/src/TextSnapshot.js

@@ -160,6 +160,9 @@ export class TextSnapshot {
         };
         const findDescendantNodes = async (backendNodeId) => {
             const descendantIds = new Set();
+            if (!backendNodeId) {
+                return descendantIds;
+            }
             try {
                 // @ts-expect-error internal API
                 const client = page.pptrPage._client();
@@ -213,6 +216,7 @@ export class TextSnapshot {
         if (extraHandles.length) {
             page.extraHandles = extraHandles;
         }
+        const reorgInfo = [];
         for (const handle of page.extraHandles) {
             const extraNode = await createExtraNode(handle);
             if (!extraNode) {
@@ -220,11 +224,13 @@ export class TextSnapshot {
             }
             idToNode.set(extraNode.id, extraNode);
             const attachTarget = (await findAncestorNode(handle)) || rootNodeWithId;
-            if (extraNode.backendNodeId !== undefined) {
-                const descendantIds = await findDescendantNodes(extraNode.backendNodeId);
-                const index = moveChildNodes(attachTarget, extraNode, descendantIds);
-                attachTarget.children.splice(index, 0, extraNode);
-            }
+            const descendantIds = await findDescendantNodes(extraNode.backendNodeId);
+            reorgInfo.push({ extraNode, attachTarget, descendantIds });
+        }
+        for (const { extraNode, attachTarget, descendantIds } of reorgInfo) {
+            const index = moveChildNodes(attachTarget, extraNode, descendantIds);
+            attachTarget.children.splice(index, 0, extraNode);
         }
     }
 }
+//# sourceMappingURL=TextSnapshot.js.map

package/build/src/WaitForHelper.js

@@ -104,8 +104,10 @@ export class WaitForHelper {
         });
     }
     async waitForEventsAfterAction(action, options) {
+        let dialogOpened = false;
         if (options?.handleDialog) {
             const dialogHandler = (dialog) => {
+                dialogOpened = true;
                 if (options.handleDialog === 'dismiss') {
                     void dialog.dismiss();
                 }
@@ -142,6 +144,9 @@ export class WaitForHelper {
         }
         try {
             await navigationFinished;
+            if (dialogOpened) {
+                return;
+            }
             // Wait for stable dom after navigation so we execute in
             // the correct context
             await this.waitForStableDom();
@@ -168,3 +173,4 @@ export function getNetworkMultiplierFromString(condition) {
     }
     return 1;
 }
+//# sourceMappingURL=WaitForHelper.js.map

package/build/src/bin/check-latest-version.js

@@ -23,3 +23,4 @@ if (cachePath) {
         // Ignore errors.
     }
 }
+//# sourceMappingURL=check-latest-version.js.map