opera-devtools-mcp 0.2.4 → 0.3.0

package/build/src/formatters/HeapSnapshotFormatter.js

@@ -3,10 +3,23 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { DevTools } from '../third_party/index.js';
 import { stableIdSymbol } from '../utils/id.js';
+const { formatBytesToKb } = DevTools.I18n.ByteUtilities;
 export function isNodeLike(item) {
     return (typeof item === 'object' && item !== null && 'id' in item && 'name' in item);
 }
+export function isEdgeLike(item) {
+    return (typeof item === 'object' &&
+        item !== null &&
+        'name' in item &&
+        'node' in item &&
+        'type' in item &&
+        typeof item.node === 'object' &&
+        item.node !== null &&
+        'id' in item.node &&
+        'name' in item.node);
+}
 export class HeapSnapshotFormatter {
     #aggregates;
     constructor(aggregates) {
@@ -14,14 +27,74 @@ export class HeapSnapshotFormatter {
     }
     static formatNodes(items) {
         const lines = [];
-        if (items.length > 0 && isNodeLike(items[0])) {
-            lines.push('id,name,type,distance,selfSize,retainedSize');
+        if (items.length > 0) {
+            const firstItem = items[0];
+            if (isNodeLike(firstItem)) {
+                lines.push('nodeId,nodeName,type,distance,selfSize,retainedSize');
+            }
+            else if (isEdgeLike(firstItem)) {
+                lines.push('name,type,nodeId,nodeName,selfSize,retainedSize');
+            }
         }
         for (const item of items) {
             if (isNodeLike(item)) {
-                lines.push(`${item.id},"${item.name}",${item.type},${item.distance},${item.selfSize},${item.retainedSize}`);
+                lines.push(`${item.id},${item.name},${item.type},${item.distance},${formatBytesToKb(item.selfSize)},${formatBytesToKb(item.retainedSize)}`);
+            }
+            else if (isEdgeLike(item)) {
+                lines.push(`${item.name},${item.type},${item.node.id},${item.node.name},${formatBytesToKb(item.node.selfSize)},${formatBytesToKb(item.node.retainedSize)}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    static formatRetainingPaths(retainingPaths) {
+        const lines = [];
+        function formatEdge(edge, depth) {
+            const indent = '  '.repeat(depth);
+            lines.push(`${indent}<- @${edge.nodeId} ${edge.nodeName} via ${edge.edgeType} ${edge.edgeName} (distance: ${edge.distance})`);
+            for (const child of edge.children) {
+                formatEdge(child, depth + 1);
             }
         }
+        for (const path of retainingPaths) {
+            formatEdge(path, 0);
+        }
+        return lines.join('\n');
+    }
+    static formatDominators(dominators) {
+        const lines = [];
+        lines.push('nodeId,nodeName,selfSize,retainedSize');
+        for (const node of dominators) {
+            lines.push(`${node.nodeId},${node.nodeName},${formatBytesToKb(node.selfSize)},${formatBytesToKb(node.retainedSize)}`);
+        }
+        return lines.join('\n');
+    }
+    static formatDuplicateStrings(groups) {
+        const lines = [];
+        lines.push('value,count,totalSelfSize,totalRetainedSize,truncated,nodeIds');
+        for (const group of groups) {
+            const nodeIds = group.nodes.map(n => `@${n.id}`).join(' ');
+            const truncated = group.truncated ?? false;
+            lines.push(`${JSON.stringify(group.value)},${group.count},${formatBytesToKb(group.totalSelfSize)},${formatBytesToKb(group.totalRetainedSize)},${truncated},${nodeIds}`);
+        }
+        return lines.join('\n');
+    }
+    static formatNativeContextSizes(sizes) {
+        const lines = [];
+        lines.push('nodeId,nodeName,selfSize,retainedSize,attributedSize');
+        const sortedContexts = [...sizes.nativeContexts].sort((a, b) => b.attributedSize - a.attributedSize);
+        for (const nc of sortedContexts) {
+            lines.push(`${nc.nodeId},${nc.nodeName},${formatBytesToKb(nc.selfSize)},${formatBytesToKb(nc.retainedSize)},${formatBytesToKb(nc.attributedSize)}`);
+        }
+        lines.push(`Shared Size: ${formatBytesToKb(sizes.sharedSize)}`);
+        lines.push(`Unattributed Size: ${formatBytesToKb(sizes.noAttributionSize)}`);
+        return lines.join('\n');
+    }
+    static formatRetainedByContextSummary(summary) {
+        const lines = [];
+        lines.push(`Context count: ${summary.contextCount}`);
+        lines.push(`Retained by context size: ${formatBytesToKb(summary.retainedByContextSize)} (${summary.retainedByContextCount} objects)`);
+        lines.push(`Not retained by context size: ${formatBytesToKb(summary.notRetainedByContextSize)} (${summary.notRetainedByContextCount} objects)`);
+        lines.push(`Total size: ${formatBytesToKb(summary.totalSize)}`);
         return lines.join('\n');
     }
     #getSortedAggregates() {
@@ -30,25 +103,83 @@ export class HeapSnapshotFormatter {
     toString() {
         const sorted = this.#getSortedAggregates();
         const lines = [];
-        lines.push('uid,className,count,selfSize,maxRetainedSize');
+        lines.push('id,name,count,selfSize,retainedSize');
         for (const info of sorted) {
-            const uid = info[stableIdSymbol] ?? '';
-            lines.push(`${uid},"${info.name}",${info.count},${info.self},${info.maxRet}`);
+            const id = info[stableIdSymbol] ?? '';
+            lines.push(`${id},${info.name},${info.count},${formatBytesToKb(info.self)},${formatBytesToKb(info.maxRet)}`);
         }
         return lines.join('\n');
     }
     toJSON() {
         const sorted = this.#getSortedAggregates();
         return sorted.map(info => ({
-            uid: info[stableIdSymbol],
+            id: info[stableIdSymbol],
             className: info.name,
             count: info.count,
-            selfSize: info.self,
-            retainedSize: info.maxRet,
+            selfSize: formatBytesToKb(info.self),
+            retainedSize: formatBytesToKb(info.maxRet),
         }));
     }
     static sort(aggregates) {
         return Object.entries(aggregates).sort((a, b) => b[1].maxRet - a[1].maxRet);
     }
+    static formatDiffSummary(diffs) {
+        const lines = [];
+        lines.push('index,className,addedCount,removedCount,countDelta,addedSize,removedSize,sizeDelta');
+        let index = 0;
+        for (const diff of diffs) {
+            lines.push(`${index},${diff.className},${diff.addedCount},${diff.removedCount},${diff.countDelta},${formatBytesToKb(diff.addedSize)},${formatBytesToKb(diff.removedSize)},${formatBytesToKb(diff.sizeDelta)}`);
+            index++;
+        }
+        return lines.join('\n');
+    }
+    static formatDiffDetails(diff) {
+        const lines = [];
+        lines.push(`${diff.className}: # new: ${diff.addedCount}, # deleted: ${diff.removedCount}, # delta: ${formatSignedCount(diff.countDelta)}, alloc size: ${formatSignedSize(diff.addedSize)}, freed size: ${formatSignedSize(diff.removedSize)}, size delta: ${formatSignedSize(diff.sizeDelta)}`);
+        const addedIds = diff.addedIds;
+        const addedSelfSizes = diff.addedSelfSizes;
+        const deletedIds = diff.deletedIds;
+        const deletedSelfSizes = diff.deletedSelfSizes;
+        lines.push(`Objects:`);
+        for (let i = 0; i < addedIds.length; i++) {
+            lines.push(`  + @${addedIds[i]} (self_size: ${formatBytesToKb(addedSelfSizes[i])})`);
+        }
+        for (let i = 0; i < deletedIds.length; i++) {
+            lines.push(`  - @${deletedIds[i]} (self_size: ${formatBytesToKb(deletedSelfSizes[i])})`);
+        }
+        return lines.join('\n');
+    }
+    static formatObjectInfo(info) {
+        const lines = [
+            `id: @${info.id}`,
+            `name: ${info.name}`,
+            `type: ${info.type}`,
+            `detachedness: ${formatDOMLinkState(info.detachedness)}`,
+            `selfSize: ${formatBytesToKb(info.selfSize)}`,
+            `retainedSize: ${formatBytesToKb(info.retainedSize)}`,
+            `distance: ${info.distance}`,
+            `edgeCount: ${info.edgeCount}`,
+            `retainerCount: ${info.retainerCount}`,
+        ];
+        return lines.join('\n');
+    }
+}
+function formatDOMLinkState(state) {
+    switch (state) {
+        case 1 /* DevTools.HeapSnapshotModel.HeapSnapshotModel.DOMLinkState.ATTACHED */:
+            return 'attached';
+        case 2 /* DevTools.HeapSnapshotModel.HeapSnapshotModel.DOMLinkState.DETACHED */:
+            return 'detached';
+        case 0 /* DevTools.HeapSnapshotModel.HeapSnapshotModel.DOMLinkState.UNKNOWN */:
+        default:
+            return 'unknown';
+    }
+}
+function formatSignedCount(n) {
+    return n > 0 ? `+${n}` : `${n}`;
+}
+function formatSignedSize(bytes) {
+    const formatted = formatBytesToKb(bytes);
+    return bytes > 0 ? `+${formatted}` : formatted;
 }
 //# sourceMappingURL=HeapSnapshotFormatter.js.map

package/build/src/formatters/IssueFormatter.js

@@ -3,9 +3,9 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { ISSUE_UTILS } from '../issue-descriptions.js';
-import { logger } from '../logger.js';
+import { ISSUE_UTILS } from '../devtools/issueDescriptions.js';
 import { DevTools } from '../third_party/index.js';
+import { logger } from '../utils/logger.js';
 export class IssueFormatter {
     #issue;
     #options;
@@ -99,7 +99,7 @@ export class IssueFormatter {
         const markdownDescription = this.#issue.getDescription();
         const filename = markdownDescription?.file;
         if (!filename) {
-            logger(`no description found for issue:` + this.#issue.code());
+            logger?.(`no description found for issue:` + this.#issue.code());
             return undefined;
         }
         // We already have the description logic in #getDescription, but title extraction is separate
@@ -107,7 +107,7 @@ export class IssueFormatter {
         // Ideally we should process markdown once.
         const rawMarkdown = ISSUE_UTILS.getIssueDescription(filename);
         if (!rawMarkdown) {
-            logger(`no markdown ${filename} found for issue:` + this.#issue.code());
+            logger?.(`no markdown ${filename} found for issue:` + this.#issue.code());
             return undefined;
         }
         try {
@@ -115,13 +115,13 @@ export class IssueFormatter {
             const markdownAst = DevTools.Marked.Marked.lexer(processedMarkdown);
             const title = DevTools.MarkdownIssueDescription.findTitleFromMarkdownAst(markdownAst);
             if (!title) {
-                logger('cannot read issue title from ' + filename);
+                logger?.('cannot read issue title from ' + filename);
                 return undefined;
             }
             return title;
         }
         catch {
-            logger('error parsing markdown for issue ' + this.#issue.code());
+            logger?.('error parsing markdown for issue ' + this.#issue.code());
             return undefined;
         }
     }
@@ -144,7 +144,7 @@ export class IssueFormatter {
     }
 }
 function convertIssueConciseToString(issue) {
-    return `msgid=${issue.id} [issue] ${issue.title} (count: ${issue.count})`;
+    return `msgid=${issue.id} [issue] ${issue.title ?? 'Unknown Issue'} (count: ${issue.count})`;
 }
 function convertIssueDetailedToString(issue) {
     const result = [];

package/build/src/formatters/NetworkFormatter.js

@@ -38,7 +38,7 @@ export class NetworkFormatter {
             const requestBodyNotAvailableMessage = '<Request body not available anymore>';
             if (this.#options.requestFilePath) {
                 if (!this.#options.saveFile) {
-                    throw new Error('saveFile is not provided');
+                    throw new Error('Unable to save the request body to a file: no saveFile callback was configured.');
                 }
                 if (data) {
                     const result = await this.#options.saveFile(Buffer.from(data), this.#options.requestFilePath, '.network-request');
@@ -65,7 +65,7 @@ export class NetworkFormatter {
                 try {
                     const buffer = await response.buffer();
                     if (!this.#options.saveFile) {
-                        throw new Error('saveFile is not provided');
+                        throw new Error('Unable to save the response body to a file: no saveFile callback was configured.');
                     }
                     const result = await this.#options.saveFile(buffer, this.#options.responseFilePath, '.network-response');
                     this.#responseBodyFilePath = result.filename;
@@ -86,7 +86,7 @@ export class NetworkFormatter {
         return convertNetworkRequestConciseToString(this.toJSON());
     }
     toStringDetailed() {
-        return converNetworkRequestDetailedToStringDetailed(this.toJSONDetailed());
+        return convertNetworkRequestDetailedToStringDetailed(this.toJSONDetailed());
     }
     toJSON() {
         return {
@@ -181,19 +181,19 @@ function convertNetworkRequestConciseToString(data) {
     // TODO truncate the URL
     return `reqid=${data.requestId} ${data.method} ${data.url} [${data.status}]${data.selectedInDevToolsUI ? ` [selected in the DevTools Network panel]` : ''}`;
 }
-function formatHeadlers(headers) {
+function formatHeaders(headers) {
     const response = [];
     for (const [name, value] of Object.entries(headers)) {
         response.push(`- ${name}:${value}`);
     }
     return response;
 }
-function converNetworkRequestDetailedToStringDetailed(data) {
+function convertNetworkRequestDetailedToStringDetailed(data) {
     const response = [];
     response.push(`## Request ${data.url}`);
     response.push(`Status: ${data.status}`);
     response.push(`### Request Headers`);
-    for (const line of formatHeadlers(data.requestHeaders)) {
+    for (const line of formatHeaders(data.requestHeaders)) {
         response.push(line);
     }
     if (data.requestBody) {
@@ -206,7 +206,7 @@ function converNetworkRequestDetailedToStringDetailed(data) {
     }
     if (data.responseHeaders) {
         response.push(`### Response Headers`);
-        for (const line of formatHeadlers(data.responseHeaders)) {
+        for (const line of formatHeaders(data.responseHeaders)) {
             response.push(line);
         }
     }
@@ -226,7 +226,9 @@ function converNetworkRequestDetailedToStringDetailed(data) {
     if (redirectChain?.length) {
         response.push(`### Redirect chain`);
         let indent = 0;
-        for (const request of redirectChain.reverse()) {
+        // `redirectChain` is already ordered by toJSONDetailed(); don't reverse it
+        // again here or the text output contradicts structuredContent (the JSON).
+        for (const request of redirectChain) {
             response.push(`${'  '.repeat(indent)}${convertNetworkRequestConciseToString(request)}`);
             indent++;
         }