chrome-devtools-mcp 0.10.2 → 0.12.0

package/build/src/DevtoolsUtils.js

@@ -3,7 +3,11 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Common, I18n, } from '../node_modules/chrome-devtools-frontend/mcp/mcp.js';
+import { DebuggerModel, Foundation, TargetManager, MarkdownIssueDescription, Marked, ProtocolClient, Common, I18n, } from '../node_modules/chrome-devtools-frontend/mcp/mcp.js';
+import { PuppeteerDevToolsConnection } from './DevToolsConnectionAdapter.js';
+import { ISSUE_UTILS } from './issue-descriptions.js';
+import { logger } from './logger.js';
+import { Mutex } from './Mutex.js';
 export function extractUrlLikeFromDevToolsTitle(title) {
     const match = title.match(new RegExp(`DevTools - (.*)`));
     return match?.[1] ?? undefined;
@@ -20,6 +24,7 @@ export function urlsEqual(url1, url2) {
  * 1. We do not care about the protocol.
  * 2. We do not care about trailing slashes.
  * 3. We do not care about "www".
+ * 4. We ignore the hash parts.
  *
  * For example, if the user types "record a trace on foo.com", we would want to
  * match a tab in the connected Chrome instance that is showing "www.foo.com/"
@@ -37,6 +42,12 @@ function normalizeUrl(url) {
     if (result.startsWith('www.')) {
         result = result.slice(4);
     }
+    // We use target URLs to locate DevTools but those often do
+    // no include hash.
+    const hashIdx = result.lastIndexOf('#');
+    if (hashIdx !== -1) {
+        result = result.slice(0, hashIdx);
+    }
     // Remove trailing slash
     if (result.endsWith('/')) {
         result = result.slice(0, -1);
@@ -53,6 +64,46 @@ export class FakeIssuesManager extends Common.ObjectWrapper
         return [];
     }
 }
+export function mapIssueToMessageObject(issue) {
+    const count = issue.getAggregatedIssuesCount();
+    const markdownDescription = issue.getDescription();
+    const filename = markdownDescription?.file;
+    if (!markdownDescription) {
+        logger(`no description found for issue:` + issue.code);
+        return null;
+    }
+    const rawMarkdown = filename
+        ? ISSUE_UTILS.getIssueDescription(filename)
+        : null;
+    if (!rawMarkdown) {
+        logger(`no markdown ${filename} found for issue:` + issue.code);
+        return null;
+    }
+    let processedMarkdown;
+    let title;
+    try {
+        processedMarkdown = MarkdownIssueDescription.substitutePlaceholders(rawMarkdown, markdownDescription.substitutions);
+        const markdownAst = Marked.Marked.lexer(processedMarkdown);
+        title = MarkdownIssueDescription.findTitleFromMarkdownAst(markdownAst);
+    }
+    catch {
+        logger('error parsing markdown for issue ' + issue.code());
+        return null;
+    }
+    if (!title) {
+        logger('cannot read issue title from ' + filename);
+        return null;
+    }
+    return {
+        type: 'issue',
+        item: issue,
+        message: title,
+        count,
+        description: processedMarkdown,
+    };
+}
+// DevTools CDP errors can get noisy.
+ProtocolClient.InspectorBackend.test.suppressRequestErrors = true;
 I18n.DevToolsLocale.DevToolsLocale.instance({
     create: true,
     data: {
@@ -62,3 +113,94 @@ I18n.DevToolsLocale.DevToolsLocale.instance({
     },
 });
 I18n.i18n.registerLocaleDataForTest('en-US', {});
+export class UniverseManager {
+    #browser;
+    #createUniverseFor;
+    #universes = new WeakMap();
+    /** Guard access to #universes so we don't create unnecessary universes */
+    #mutex = new Mutex();
+    constructor(browser, factory = DEFAULT_FACTORY) {
+        this.#browser = browser;
+        this.#createUniverseFor = factory;
+    }
+    async init(pages) {
+        try {
+            await this.#mutex.acquire();
+            const promises = [];
+            for (const page of pages) {
+                promises.push(this.#createUniverseFor(page).then(targetUniverse => this.#universes.set(page, targetUniverse)));
+            }
+            this.#browser.on('targetcreated', this.#onTargetCreated);
+            this.#browser.on('targetdestroyed', this.#onTargetDestroyed);
+            await Promise.all(promises);
+        }
+        finally {
+            this.#mutex.release();
+        }
+    }
+    get(page) {
+        return this.#universes.get(page) ?? null;
+    }
+    dispose() {
+        this.#browser.off('targetcreated', this.#onTargetCreated);
+        this.#browser.off('targetdestroyed', this.#onTargetDestroyed);
+    }
+    #onTargetCreated = async (target) => {
+        const page = await target.page();
+        try {
+            await this.#mutex.acquire();
+            if (!page || this.#universes.has(page)) {
+                return;
+            }
+            this.#universes.set(page, await this.#createUniverseFor(page));
+        }
+        finally {
+            this.#mutex.release();
+        }
+    };
+    #onTargetDestroyed = async (target) => {
+        const page = await target.page();
+        try {
+            await this.#mutex.acquire();
+            if (!page || !this.#universes.has(page)) {
+                return;
+            }
+            this.#universes.delete(page);
+        }
+        finally {
+            this.#mutex.release();
+        }
+    };
+}
+const DEFAULT_FACTORY = async (page) => {
+    const settingStorage = new Common.Settings.SettingsStorage({});
+    const universe = new Foundation.Universe.Universe({
+        settingsCreationOptions: {
+            syncedStorage: settingStorage,
+            globalStorage: settingStorage,
+            localStorage: settingStorage,
+            settingRegistrations: Common.SettingRegistration.getRegisteredSettings(),
+        },
+        overrideAutoStartModels: new Set([DebuggerModel]),
+    });
+    const session = await page.createCDPSession();
+    const connection = new PuppeteerDevToolsConnection(session);
+    const targetManager = universe.context.get(TargetManager);
+    targetManager.observeModels(DebuggerModel, SKIP_ALL_PAUSES);
+    const target = targetManager.createTarget('main', '', 'frame', // eslint-disable-line @typescript-eslint/no-explicit-any
+    /* parentTarget */ null, session.id(), undefined, connection);
+    return { target, universe };
+};
+// We don't want to pause any DevTools universe session ever on the MCP side.
+//
+// Note that calling `setSkipAllPauses` only affects the session on which it was
+// sent. This means DevTools can still pause, step and do whatever. We just won't
+// see the `Debugger.paused`/`Debugger.resumed` events on the MCP side.
+const SKIP_ALL_PAUSES = {
+    modelAdded(model) {
+        void model.agent.invoke_setSkipAllPauses({ skip: true });
+    },
+    modelRemoved() {
+        // Do nothing.
+    },
+};

package/build/src/McpContext.js

@@ -54,6 +54,7 @@ export class McpContext {
     #isRunningTrace = false;
     #networkConditionsMap = new WeakMap();
     #cpuThrottlingRateMap = new WeakMap();
+    #geolocationMap = new WeakMap();
     #dialog;
     #nextSnapshotId = 1;
     #traceResults = [];
@@ -64,7 +65,7 @@ export class McpContext {
         this.logger = logger;
         this.#locatorClass = locatorClass;
         this.#options = options;
-        this.#networkCollector = new NetworkCollector(this.browser, undefined, this.#options.experimentalIncludeAllPages);
+        this.#networkCollector = new NetworkCollector(this.browser);
         this.#consoleCollector = new ConsoleCollector(this.browser, collect => {
             return {
                 console: event => {
@@ -84,12 +85,12 @@ export class McpContext {
                     collect(event);
                 },
             };
-        }, this.#options.experimentalIncludeAllPages);
+        });
     }
     async #init() {
-        await this.createPagesSnapshot();
-        await this.#networkCollector.init();
-        await this.#consoleCollector.init();
+        const pages = await this.createPagesSnapshot();
+        await this.#networkCollector.init(pages);
+        await this.#consoleCollector.init(pages);
     }
     dispose() {
         this.#networkCollector.dispose();
@@ -123,8 +124,12 @@ export class McpContext {
             this.logger('no cdpBackendNodeId');
             return;
         }
+        if (this.#textSnapshot === null) {
+            this.logger('no text snapshot');
+            return;
+        }
         // TODO: index by backendNodeId instead.
-        const queue = [this.#textSnapshot?.root];
+        const queue = [this.#textSnapshot.root];
         while (queue.length) {
             const current = queue.pop();
             if (current.backendNodeId === cdpBackendNodeId) {
@@ -191,6 +196,19 @@ export class McpContext {
         const page = this.getSelectedPage();
         return this.#cpuThrottlingRateMap.get(page) ?? 1;
     }
+    setGeolocation(geolocation) {
+        const page = this.getSelectedPage();
+        if (geolocation === null) {
+            this.#geolocationMap.delete(page);
+        }
+        else {
+            this.#geolocationMap.set(page, geolocation);
+        }
+    }
+    getGeolocation() {
+        const page = this.getSelectedPage();
+        return this.#geolocationMap.get(page) ?? null;
+    }
     setIsRunningPerformanceTrace(x) {
         this.#isRunningTrace = x;
     }
@@ -284,7 +302,8 @@ export class McpContext {
             return (this.#options.experimentalDevToolsDebugging ||
                 !page.url().startsWith('devtools://'));
         });
-        if (!this.#selectedPage || this.#pages.indexOf(this.#selectedPage) === -1) {
+        if ((!this.#selectedPage || this.#pages.indexOf(this.#selectedPage) === -1) &&
+            this.#pages[0]) {
             this.selectPage(this.#pages[0]);
         }
         await this.detectOpenDevToolsWindows();
@@ -395,9 +414,12 @@ export class McpContext {
             root: rootNodeWithId,
             snapshotId: String(snapshotId),
             idToNode,
+            hasSelectedElement: false,
+            verbose,
         };
         const data = devtoolsData ?? (await this.getDevToolsData());
         if (data?.cdpBackendNodeId) {
+            this.#textSnapshot.hasSelectedElement = true;
             this.#textSnapshot.selectedElementUid = this.resolveCdpElementId(data?.cdpBackendNodeId);
         }
     }
@@ -446,15 +468,15 @@ export class McpContext {
     getNetworkRequestStableId(request) {
         return this.#networkCollector.getIdForResource(request);
     }
-    waitForTextOnPage({ text, timeout, }) {
+    waitForTextOnPage(text, timeout) {
         const page = this.getSelectedPage();
         const frames = page.frames();
-        const locator = this.#locatorClass.race(frames.flatMap(frame => [
+        let locator = this.#locatorClass.race(frames.flatMap(frame => [
             frame.locator(`aria/${text}`),
             frame.locator(`text/${text}`),
         ]));
         if (timeout) {
-            locator.setTimeout(timeout);
+            locator = locator.setTimeout(timeout);
         }
         return locator.wait();
     }
@@ -472,6 +494,6 @@ export class McpContext {
                 },
             };
         });
-        await this.#networkCollector.init();
+        await this.#networkCollector.init(await this.browser.pages());
     }
 }

package/build/src/McpResponse.js

@@ -3,12 +3,11 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { AggregatedIssue, Marked, findTitleFromMarkdownAst, } from '../node_modules/chrome-devtools-frontend/mcp/mcp.js';
+import { AggregatedIssue } from '../node_modules/chrome-devtools-frontend/mcp/mcp.js';
+import { mapIssueToMessageObject } from './DevtoolsUtils.js';
 import { formatConsoleEventShort, formatConsoleEventVerbose, } from './formatters/consoleFormatter.js';
 import { getFormattedHeaderValue, getFormattedResponseBody, getFormattedRequestBody, getShortDescriptionForRequest, getStatusFromRequest, } from './formatters/networkFormatter.js';
 import { formatSnapshotNode } from './formatters/snapshotFormatter.js';
-import { getIssueDescription } from './issue-descriptions.js';
-import { logger } from './logger.js';
 import { handleDialog } from './tools/pages.js';
 import { paginate } from './utils/pagination.js';
 export class McpResponse {
@@ -156,6 +155,15 @@ export class McpResponse {
                     })),
                 };
             }
+            else if (message instanceof AggregatedIssue) {
+                const mappedIssueMessage = mapIssueToMessageObject(message);
+                if (!mappedIssueMessage)
+                    throw new Error("Can't provide detals for the msgid " + consoleMessageStableId);
+                consoleData = {
+                    consoleMessageStableId,
+                    ...mappedIssueMessage,
+                };
+            }
             else {
                 consoleData = {
                     consoleMessageStableId,
@@ -199,28 +207,12 @@ export class McpResponse {
                     };
                 }
                 if (item instanceof AggregatedIssue) {
-                    const count = item.getAggregatedIssuesCount();
-                    const filename = item.getDescription()?.file;
-                    const rawMarkdown = filename
-                        ? getIssueDescription(filename)
-                        : null;
-                    if (!rawMarkdown) {
-                        logger(`no markdown ${filename} found for issue:` + item.code);
+                    const mappedIssueMessage = mapIssueToMessageObject(item);
+                    if (!mappedIssueMessage)
                         return null;
-                    }
-                    const markdownAst = Marked.Marked.lexer(rawMarkdown);
-                    const title = findTitleFromMarkdownAst(markdownAst);
-                    if (!title) {
-                        logger('cannot read issue title from ' + filename);
-                        return null;
-                    }
                     return {
                         consoleMessageStableId,
-                        type: 'issue',
-                        item,
-                        message: title,
-                        count,
-                        args: [],
+                        ...mappedIssueMessage,
                     };
                 }
                 return {
@@ -273,11 +265,11 @@ Call ${handleDialog.name} to handle it before continuing.`);
             response.push(...parts);
         }
         if (data.formattedSnapshot) {
-            response.push('## Page content');
+            response.push('## Latest page snapshot');
             response.push(data.formattedSnapshot);
         }
         response.push(...this.#formatNetworkRequestData(context, data.bodies));
-        response.push(...this.#formatConsoleData(data.consoleData));
+        response.push(...this.#formatConsoleData(context, data.consoleData));
         if (this.#networkRequestsOptions?.include) {
             let requests = context.getNetworkRequests(this.#networkRequestsOptions?.includePreservedRequests);
             // Apply resource type filtering if specified
@@ -346,12 +338,12 @@ Call ${handleDialog.name} to handle it before continuing.`);
             items: paginationResult.items,
         };
     }
-    #formatConsoleData(data) {
+    #formatConsoleData(context, data) {
         const response = [];
         if (!data) {
             return response;
         }
-        response.push(formatConsoleEventVerbose(data));
+        response.push(formatConsoleEventVerbose(data, context));
         return response;
     }
     #formatNetworkRequestData(context, data) {

package/build/src/PageCollector.js

@@ -5,7 +5,6 @@
  */
 import { createIssuesFromProtocolIssue, IssueAggregator, } from '../node_modules/chrome-devtools-frontend/mcp/mcp.js';
 import { FakeIssuesManager } from './DevtoolsUtils.js';
-import { features } from './features.js';
 import { logger } from './logger.js';
 function createIdGenerator() {
     let i = 1;
@@ -22,20 +21,17 @@ export class PageCollector {
     #listenersInitializer;
     #listeners = new WeakMap();
     #maxNavigationSaved = 3;
-    #includeAllPages;
     /**
      * This maps a Page to a list of navigations with a sub-list
      * of all collected resources.
      * The newer navigations come first.
      */
     storage = new WeakMap();
-    constructor(browser, listeners, includeAllPages) {
+    constructor(browser, listeners) {
         this.#browser = browser;
         this.#listenersInitializer = listeners;
-        this.#includeAllPages = includeAllPages;
     }
-    async init() {
-        const pages = await this.#browser.pages(this.#includeAllPages);
+    async init(pages) {
         for (const page of pages) {
             this.addPage(page);
         }
@@ -154,9 +150,6 @@ export class ConsoleCollector extends PageCollector {
     #subscribedPages = new WeakMap();
     addPage(page) {
         super.addPage(page);
-        if (!features.issues) {
-            return;
-        }
         if (!this.#subscribedPages.has(page)) {
             const subscriber = new PageIssueSubscriber(page);
             this.#subscribedPages.set(page, subscriber);
@@ -262,8 +255,8 @@ export class NetworkCollector extends PageCollector {
                 collect(req);
             },
         };
-    }, includeAllPages) {
-        super(browser, listeners, includeAllPages);
+    }) {
+        super(browser, listeners);
     }
     splitAfterNavigation(page) {
         const navigations = this.storage.get(page) ?? [];

package/build/src/browser.js

@@ -19,6 +19,10 @@ function makeTargetFilter() {
         if (target.url() === 'chrome://newtab/') {
             return true;
         }
+        // Could be the only page opened in the browser.
+        if (target.url().startsWith('chrome://inspect')) {
+            return true;
+        }
         for (const prefix of ignoredPrefixes) {
             if (target.url().startsWith(prefix)) {
                 return false;
@@ -28,6 +32,7 @@ function makeTargetFilter() {
     };
 }
 export async function ensureBrowserConnected(options) {
+    const { channel } = options;
     if (browser?.connected) {
         return browser;
     }
@@ -45,11 +50,56 @@ export async function ensureBrowserConnected(options) {
     else if (options.browserURL) {
         connectOptions.browserURL = options.browserURL;
     }
+    else if (channel || options.userDataDir) {
+        const userDataDir = options.userDataDir;
+        if (userDataDir) {
+            // TODO: re-expose this logic via Puppeteer.
+            const portPath = path.join(userDataDir, 'DevToolsActivePort');
+            try {
+                const fileContent = await fs.promises.readFile(portPath, 'utf8');
+                const [rawPort, rawPath] = fileContent
+                    .split('\n')
+                    .map(line => {
+                    return line.trim();
+                })
+                    .filter(line => {
+                    return !!line;
+                });
+                if (!rawPort || !rawPath) {
+                    throw new Error(`Invalid DevToolsActivePort '${fileContent}' found`);
+                }
+                const port = parseInt(rawPort, 10);
+                if (isNaN(port) || port <= 0 || port > 65535) {
+                    throw new Error(`Invalid port '${rawPort}' found`);
+                }
+                const browserWSEndpoint = `ws://127.0.0.1:${port}${rawPath}`;
+                connectOptions.browserWSEndpoint = browserWSEndpoint;
+            }
+            catch (error) {
+                throw new Error(`Could not connect to Chrome in ${userDataDir}. Check if Chrome is running and remote debugging is enabled.`, {
+                    cause: error,
+                });
+            }
+        }
+        else {
+            if (!channel) {
+                throw new Error('Channel must be provided if userDataDir is missing');
+            }
+            connectOptions.channel = (channel === 'stable' ? 'chrome' : `chrome-${channel}`);
+        }
+    }
     else {
-        throw new Error('Either browserURL or wsEndpoint must be provided');
+        throw new Error('Either browserURL, wsEndpoint, channel or userDataDir must be provided');
     }
     logger('Connecting Puppeteer to ', JSON.stringify(connectOptions));
-    browser = await puppeteer.connect(connectOptions);
+    try {
+        browser = await puppeteer.connect(connectOptions);
+    }
+    catch (err) {
+        throw new Error('Could not connect to Chrome. Check if Chrome is running and remote debugging is enabled by going to chrome://inspect/#remote-debugging.', {
+            cause: err,
+        });
+    }
     logger('Connected Puppeteer');
     return browser;
 }

package/build/src/cli.js

@@ -5,9 +5,21 @@
  */
 import { yargs, hideBin } from './third_party/index.js';
 export const cliOptions = {
+    autoConnect: {
+        type: 'boolean',
+        description: 'If specified, automatically connects to a browser (Chrome 145+) running in the user data directory identified by the channel param. Requires remote debugging being enabled in Chrome here: chrome://inspect/#remote-debugging.',
+        conflicts: ['isolated', 'executablePath'],
+        default: false,
+        coerce: (value) => {
+            if (!value) {
+                return;
+            }
+            return value;
+        },
+    },
     browserUrl: {
         type: 'string',
-        description: 'Connect to a running Chrome instance using port forwarding. For more details see: https://developer.chrome.com/docs/devtools/remote-debugging/local-server.',
+        description: 'Connect to a running, debuggable Chrome instance (e.g. `http://127.0.0.1:9222`). For more details see: https://github.com/ChromeDevTools/chrome-devtools-mcp#connecting-to-a-running-chrome-instance.',
         alias: 'u',
         conflicts: 'wsEndpoint',
         coerce: (url) => {
@@ -80,8 +92,12 @@ export const cliOptions = {
     },
     isolated: {
         type: 'boolean',
-        description: 'If specified, creates a temporary user-data-dir that is automatically cleaned up after the browser is closed.',
-        default: false,
+        description: 'If specified, creates a temporary user-data-dir that is automatically cleaned up after the browser is closed. Defaults to false.',
+    },
+    userDataDir: {
+        type: 'string',
+        description: 'Path to the user data directory for Chrome. Default is $HOME/.cache/chrome-devtools-mcp/chrome-profile$CHANNEL_SUFFIX_IF_NON_STABLE',
+        conflicts: ['browserUrl', 'wsEndpoint', 'isolated'],
     },
     channel: {
         type: 'string',
@@ -196,6 +212,18 @@ export function parseArguments(version, argv = process.argv) {
             'Disable tools in the performance category',
         ],
         ['$0 --no-category-network', 'Disable tools in the network category'],
+        [
+            '$0 --user-data-dir=/tmp/user-data-dir',
+            'Use a custom user data directory',
+        ],
+        [
+            '$0 --auto-connect',
+            'Connect to a stable Chrome instance (Chrome 145+) running instead of launching a new instance',
+        ],
+        [
+            '$0 --auto-connect --channel=canary',
+            'Connect to a canary Chrome instance (Chrome 145+) running instead of launching a new instance',
+        ],
     ]);
     return yargsInstance
         .wrap(Math.min(120, yargsInstance.terminalWidth()))

package/build/src/formatters/consoleFormatter.js

@@ -19,11 +19,12 @@ function getArgs(msg) {
     return args;
 }
 // The verbose format for a console message, including all details.
-export function formatConsoleEventVerbose(msg) {
+export function formatConsoleEventVerbose(msg, context) {
+    const aggregatedIssue = msg.item;
     const result = [
         `ID: ${msg.consoleMessageStableId}`,
-        `Message: ${msg.type}> ${msg.message}`,
-        formatArgs(msg),
+        `Message: ${msg.type}> ${aggregatedIssue ? formatIssue(aggregatedIssue, msg.description, context) : msg.message}`,
+        aggregatedIssue ? undefined : formatArgs(msg),
     ].filter(line => !!line);
     return result.join('\n');
 }
@@ -41,3 +42,80 @@ function formatArgs(consoleData) {
     }
     return result.join('\n');
 }
+export function formatIssue(issue, description, context) {
+    const result = [];
+    let processedMarkdown = description?.trim();
+    // Remove heading in order not to conflict with the whole console message response markdown
+    if (processedMarkdown?.startsWith('# ')) {
+        processedMarkdown = processedMarkdown.substring(2).trimStart();
+    }
+    if (processedMarkdown)
+        result.push(processedMarkdown);
+    const links = issue.getDescription()?.links;
+    if (links && links.length > 0) {
+        result.push('Learn more:');
+        for (const link of links) {
+            result.push(`[${link.linkTitle}](${link.link})`);
+        }
+    }
+    const issues = issue.getAllIssues();
+    const affectedResources = [];
+    for (const singleIssue of issues) {
+        const details = singleIssue.details();
+        if (!details)
+            continue;
+        // We send the remaining details as untyped JSON because the DevTools
+        // frontend code is currently not re-usable.
+        // eslint-disable-next-line
+        const data = structuredClone(details);
+        let uid;
+        let request;
+        if ('violatingNodeId' in details && details.violatingNodeId && context) {
+            uid = context.resolveCdpElementId(details.violatingNodeId);
+            delete data.violatingNodeId;
+        }
+        if ('nodeId' in details && details.nodeId && context) {
+            uid = context.resolveCdpElementId(details.nodeId);
+            delete data.nodeId;
+        }
+        if ('documentNodeId' in details && details.documentNodeId && context) {
+            uid = context.resolveCdpElementId(details.documentNodeId);
+            delete data.documentNodeId;
+        }
+        if ('request' in details && details.request) {
+            request = details.request.url;
+            if (details.request.requestId && context) {
+                const resolvedId = context.resolveCdpRequestId(details.request.requestId);
+                if (resolvedId) {
+                    request = resolvedId;
+                    delete data.request.requestId;
+                }
+            }
+        }
+        // These fields has no use for the MCP client (redundant or irrelevant).
+        delete data.errorType;
+        delete data.frameId;
+        affectedResources.push({
+            uid,
+            data: data,
+            request,
+        });
+    }
+    if (affectedResources.length) {
+        result.push('### Affected resources');
+    }
+    result.push(...affectedResources.map(item => {
+        const details = [];
+        if (item.uid)
+            details.push(`uid=${item.uid}`);
+        if (item.request) {
+            details.push((typeof item.request === 'number' ? `reqid=` : 'url=') + item.request);
+        }
+        if (item.data)
+            details.push(`data=${JSON.stringify(item.data)}`);
+        return details.join(' ');
+    }));
+    if (result.length === 0)
+        return 'No affected resources found';
+    return result.join('\n');
+}