Merge branch 'main' into mcp-dialog-pt1

Author: samiyac

package.json

@@ -36,7 +36,8 @@
   "files": [
     "build/src",
     "LICENSE",
-    "!*.tsbuildinfo"
+    "!*.tsbuildinfo",
+    "!*.js.map"
   ],
   "repository": "ChromeDevTools/chrome-devtools-mcp",
   "author": "Google LLC",

src/HeapSnapshotManager.ts

@@ -99,6 +99,23 @@ export class HeapSnapshotManager {
     return uid;
   }
 
+  async getNodesByUid(
+    filePath: string,
+    uid: number,
+  ): Promise<DevTools.HeapSnapshotModel.HeapSnapshotModel.ItemsRange> {
+    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: string) {
     const absolutePath = path.resolve(filePath);
     const cached = this.#snapshots.get(absolutePath);
@@ -108,6 +125,14 @@ export class HeapSnapshotManager {
     return cached;
   }
 
+  async resolveClassKeyFromUid(
+    filePath: string,
+    uid: number,
+  ): Promise<string | undefined> {
+    const cached = this.#getCachedSnapshot(filePath);
+    return cached.uidToClassKey.get(uid);
+  }
+
   async #loadSnapshot(absolutePath: string): Promise<{
     snapshot: DevTools.HeapSnapshotModel.HeapSnapshotProxy.HeapSnapshotProxy;
     worker: DevTools.HeapSnapshotModel.HeapSnapshotProxy.HeapSnapshotWorkerProxy;

src/McpContext.ts

@@ -765,4 +765,11 @@ export class McpContext implements Context {
   ): Promise<DevTools.HeapSnapshotModel.HeapSnapshotModel.StaticData | null> {
     return await this.#heapSnapshotManager.getStaticData(filePath);
   }
+
+  async getHeapSnapshotNodesByUid(
+    filePath: string,
+    uid: number,
+  ): Promise<DevTools.HeapSnapshotModel.HeapSnapshotModel.ItemsRange> {
+    return await this.#heapSnapshotManager.getNodesByUid(filePath, uid);
+  }
 }

src/McpResponse.ts

@@ -179,6 +179,7 @@ export class McpResponse implements Response {
     pagination?: PaginationOptions;
     stats?: DevTools.HeapSnapshotModel.HeapSnapshotModel.Statistics;
     staticData?: DevTools.HeapSnapshotModel.HeapSnapshotModel.StaticData | null;
+    nodes?: DevTools.HeapSnapshotModel.HeapSnapshotModel.ItemsRange;
   };
   #networkRequestsOptions?: {
     include: boolean;
@@ -404,6 +405,18 @@ export class McpResponse implements Response {
     };
   }
 
+  setHeapSnapshotNodes(
+    nodes: DevTools.HeapSnapshotModel.HeapSnapshotModel.ItemsRange,
+    options?: PaginationOptions,
+  ) {
+    this.#heapSnapshotOptions = {
+      ...this.#heapSnapshotOptions,
+      include: true,
+      nodes,
+      pagination: options,
+    };
+  }
+
   attachImage(value: ImageContentData): void {
     this.#images.push(value);
   }
@@ -701,6 +714,7 @@ export class McpResponse implements Response {
         staticData?: object;
       };
       heapSnapshotData?: object[];
+      heapSnapshotNodes?: readonly object[];
       extensionServiceWorkers?: object[];
       extensionPages?: object[];
     } = {};
@@ -929,6 +943,20 @@ Call ${handleDialog.name} to handle it before continuing.`);
         response.push(formatter.toString());
         structuredContent.heapSnapshotData = formatter.toJSON();
       }
+      const nodes = this.#heapSnapshotOptions.nodes;
+      if (nodes) {
+        const paginationData = this.#dataWithPagination(
+          nodes.items,
+          this.#heapSnapshotOptions.pagination,
+        );
+
+        response.push(HeapSnapshotFormatter.formatNodes(paginationData.items));
+
+        structuredContent.pagination = paginationData.pagination;
+        response.push(...paginationData.info);
+
+        structuredContent.heapSnapshotNodes = paginationData.items;
+      }
     }
 
     if (data.detailedNetworkRequest) {
@@ -1031,17 +1059,16 @@ Call ${handleDialog.name} to handle it before continuing.`);
 
       response.push('## Console messages');
       if (messages.length) {
+        const grouped = ConsoleFormatter.groupConsecutive(messages);
         const paginationData = this.#dataWithPagination(
-          messages,
+          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>');

src/TextSnapshot.ts

@@ -231,9 +231,12 @@ export class TextSnapshot {
     };
 
     const findDescendantNodes = async (
-      backendNodeId: number,
+      backendNodeId?: number,
     ): Promise<Set<number>> => {
       const descendantIds = new Set<number>();
+      if (!backendNodeId) {
+        return descendantIds;
+      }
       try {
         // @ts-expect-error internal API
         const client = page.pptrPage._client();
@@ -297,20 +300,26 @@ export class TextSnapshot {
     if (extraHandles.length) {
       page.extraHandles = extraHandles;
     }
+    const reorgInfo: Array<{
+      extraNode: TextSnapshotNode;
+      attachTarget: TextSnapshotNode;
+      descendantIds: Set<number>;
+    }> = [];
+
     for (const handle of page.extraHandles) {
       const extraNode = await createExtraNode(handle);
       if (!extraNode) {
         continue;
       }
       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);
     }
   }
 }

src/formatters/ConsoleFormatter.ts

@@ -13,6 +13,8 @@ import {UncaughtError} from '../PageCollector.js';
 import * as DevTools from '../third_party/index.js';
 import type {ConsoleMessage} from '../third_party/index.js';
 
+import type {IssueFormatter} from './IssueFormatter.js';
+
 export interface ConsoleFormatterOptions {
   fetchDetailedData?: boolean;
   id: number;
@@ -32,6 +34,7 @@ interface ConsoleMessageConcise {
   text: string;
   argsCount: number;
   id: number;
+  count?: number;
 }
 
 interface ConsoleMessageDetailed extends ConsoleMessageConcise {
@@ -54,7 +57,7 @@ export class ConsoleFormatter {
 
   readonly isIgnored: IgnoreCheck;
 
-  private constructor(params: {
+  protected constructor(params: {
     id: number;
     type: string;
     text: string;
@@ -201,6 +204,48 @@ export class ConsoleFormatter {
     };
   }
 
+  /**
+   * Groups consecutive messages with the same type, text, and argument count.
+   * Similar to Chrome DevTools' console grouping behavior.
+   */
+  static groupConsecutive(
+    messages: Array<ConsoleFormatter | IssueFormatter>,
+  ): Array<ConsoleFormatter | IssueFormatter> {
+    const grouped: Array<{
+      message: ConsoleFormatter | IssueFormatter;
+      count: number;
+    }> = [];
+    for (const msg of messages) {
+      const prev = grouped[grouped.length - 1];
+      if (
+        prev &&
+        prev.message instanceof ConsoleFormatter &&
+        msg instanceof ConsoleFormatter &&
+        prev.message.#type === msg.#type &&
+        prev.message.#text === msg.#text &&
+        prev.message.#argCount === msg.#argCount
+      ) {
+        prev.count++;
+      } else {
+        grouped.push({message: msg, count: 1});
+      }
+    }
+    return grouped.map(({message, count}) =>
+      count > 1 && message instanceof ConsoleFormatter
+        ? new GroupedConsoleFormatter(
+            {
+              id: message.#id,
+              type: message.#type,
+              text: message.#text,
+              argCount: message.#argCount,
+              isIgnored: message.isIgnored,
+            },
+            count,
+          )
+        : message,
+    );
+  }
+
   toJSONDetailed(): ConsoleMessageDetailed {
     return {
       id: this.#id,
@@ -215,8 +260,37 @@ export class ConsoleFormatter {
   }
 }
 
+export class GroupedConsoleFormatter extends ConsoleFormatter {
+  readonly #count: number;
+
+  constructor(
+    params: {
+      id: number;
+      type: string;
+      text: string;
+      argCount: number;
+      isIgnored: IgnoreCheck;
+    },
+    count: number,
+  ) {
+    super(params);
+    this.#count = count;
+  }
+
+  override toString(): string {
+    return convertConsoleMessageConciseToString(this.toJSON());
+  }
+
+  override toJSON(): ConsoleMessageConcise {
+    const json = super.toJSON();
+    json.count = this.#count;
+    return json;
+  }
+}
+
 function convertConsoleMessageConciseToString(msg: ConsoleMessageConcise) {
-  return `msgid=${msg.id} [${msg.type}] ${msg.text} (${msg.argsCount} args)`;
+  const countSuffix = msg.count && msg.count > 1 ? ` [${msg.count} times]` : '';
+  return `msgid=${msg.id} [${msg.type}] ${msg.text} (${msg.argsCount} args)${countSuffix}`;
 }
 
 function convertConsoleMessageConciseDetailedToString(

src/formatters/HeapSnapshotFormatter.ts

@@ -16,13 +16,44 @@ export interface FormattedSnapshotEntry {
   retainedSize: number;
 }
 
+function isNodeLike(
+  item: unknown,
+): item is DevTools.HeapSnapshotModel.HeapSnapshotModel.Node {
+  return (
+    typeof item === 'object' && item !== null && 'id' in item && 'name' in item
+  );
+}
+
 export class HeapSnapshotFormatter {
   #aggregates: Record<string, AggregatedInfoWithUid>;
 
   constructor(aggregates: Record<string, AggregatedInfoWithUid>) {
     this.#aggregates = aggregates;
   }
 
+  static formatNodes(
+    items: ReadonlyArray<
+      | DevTools.HeapSnapshotModel.HeapSnapshotModel.Node
+      | DevTools.HeapSnapshotModel.HeapSnapshotModel.Edge
+    >,
+  ): string {
+    const lines: string[] = [];
+
+    if (items.length > 0 && isNodeLike(items[0])) {
+      lines.push('id,name,type,distance,selfSize,retainedSize');
+    }
+
+    for (const item of items) {
+      if (isNodeLike(item)) {
+        lines.push(
+          `${item.id},"${item.name}",${item.type},${item.distance},${item.selfSize},${item.retainedSize}`,
+        );
+      }
+    }
+
+    return lines.join('\n');
+  }
+
   #getSortedAggregates(): AggregatedInfoWithUid[] {
     return Object.values(this.#aggregates).sort((a, b) => b.self - a.self);
   }

src/formatters/SnapshotFormatter.ts

@@ -20,7 +20,7 @@ export class SnapshotFormatter {
 
     // Top-level content of the snapshot.
     if (
-      this.#snapshot.verbose &&
+      !this.#snapshot.verbose &&
       this.#snapshot.hasSelectedElement &&
       !this.#snapshot.selectedElementUid
     ) {

src/telemetry/tool_call_metrics.json

@@ -591,5 +591,22 @@
         "argType": "number"
       }
     ]
+  },
+  {
+    "name": "get_nodes_by_class",
+    "args": [
+      {
+        "name": "file_path_length",
+        "argType": "number"
+      },
+      {
+        "name": "page_idx",
+        "argType": "number"
+      },
+      {
+        "name": "page_size",
+        "argType": "number"
+      }
+    ]
   }
 ]