chore: structured content for console

Author: OrKoN

src/McpResponse.ts

@@ -432,6 +432,8 @@ Call ${handleDialog.name} to handle it before continuing.`);
       tabId?: string;
       networkRequest?: object;
       networkRequests?: object[];
+      detailedConsoleMessage?: object;
+      consoleMessages?: object[];
     } = {};
 
     if (this.#tabId) {
@@ -457,6 +459,10 @@ Call ${handleDialog.name} to handle it before continuing.`);
     response.push(
       ...this.#formatConsoleData(context, data.detailedConsoleMessage),
     );
+    if (data.detailedConsoleMessage) {
+      structuredContent.detailedConsoleMessage =
+        data.detailedConsoleMessage.toJSONDetailed();
+    }
 
     if (this.#networkRequestsOptions?.include) {
       let requests = context.getNetworkRequests(
@@ -511,6 +517,9 @@ Call ${handleDialog.name} to handle it before continuing.`);
             return message.toString();
           }),
         );
+        structuredContent.consoleMessages = data.items.map(message =>
+          message.toJSON(),
+        );
       } else {
         response.push('<no console messages found>');
       }

src/formatters/ConsoleFormatter.ts

@@ -18,6 +18,21 @@ export interface ConsoleFormatterOptions {
   resolvedStackTraceForTesting?: DevTools.DevTools.StackTrace.StackTrace.StackTrace;
 }
 
+export interface ConsoleFormatterJson {
+  type: string;
+  text: string;
+  argsCount: number;
+  id?: number;
+}
+
+export interface ConsoleFormatterJsonDetailed {
+  id?: number;
+  type: string;
+  text: string;
+  args: unknown[];
+  stackTrace?: DevTools.DevTools.StackTrace.StackTrace.StackTrace;
+}
+
 export class ConsoleFormatter {
   #msg: ConsoleMessage | Error;
   #resolvedArgs: unknown[] = [];
@@ -171,4 +186,27 @@ export class ConsoleFormatter {
     }
     return result;
   }
+  toJSON(): ConsoleFormatterJson {
+    return {
+      type: this.#getType(),
+      text: this.#getText(),
+      argsCount:
+        this.#msg instanceof Error
+          ? 0
+          : this.#resolvedArgs.length || this.#msg.args().length,
+      id: this.#id,
+    };
+  }
+
+  toJSONDetailed(): ConsoleFormatterJsonDetailed {
+    return {
+      id: this.#id,
+      type: this.#getType(),
+      text: this.#getText(),
+      args: this.#getArgs().map(arg =>
+        typeof arg === 'object' ? arg : String(arg),
+      ),
+      stackTrace: this.#resolvedStackTrace,
+    };
+  }
 }

src/formatters/IssueFormatter.ts

@@ -14,6 +14,29 @@ export interface IssueFormatterOptions {
   id?: number;
 }
 
+export interface IssueFormatterJson {
+  type: 'issue';
+  title: string | undefined;
+  count: number;
+  id?: number;
+}
+
+export interface AffectedResource {
+  uid?: string;
+  data?: unknown;
+  request?: string | number;
+}
+
+export interface IssueFormatterJsonDetailed {
+  id?: number;
+  type: 'issue';
+  title: string | undefined;
+  description: string | undefined;
+  links?: ReadonlyArray<{link: string; linkTitle: string}>;
+  affectedResources: AffectedResource[];
+}
+
+
 export class IssueFormatter {
   #issue: DevTools.AggregatedIssue;
   #options: IssueFormatterOptions;
@@ -59,6 +82,55 @@ export class IssueFormatter {
       }
     }
 
+    const affectedResources = this.#getAffectedResources();
+    if (affectedResources.length) {
+      bodyParts.push('### Affected resources');
+      bodyParts.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(' ');
+        }),
+      );
+    }
+
+    result.push(`Message: issue> ${bodyParts.join('\n')}`);
+
+    return result.join('\n');
+  }
+
+  toJSON(): IssueFormatterJson {
+    return {
+      type: 'issue',
+      title: this.#getTitle(),
+      count: this.#issue.getAggregatedIssuesCount(),
+      id: this.#options.id,
+    };
+  }
+
+  toJSONDetailed(): IssueFormatterJsonDetailed {
+    return {
+      id: this.#options.id,
+      type: 'issue',
+      title: this.#getTitle(),
+      description: this.#getDescription(),
+      links: this.#issue.getDescription()?.links,
+      affectedResources: this.#getAffectedResources(),
+    };
+  }
+
+  #getAffectedResources(): AffectedResource[] {
     const issues = this.#issue.getAllIssues();
     const affectedResources: Array<{
       uid?: string;
@@ -73,8 +145,7 @@ export class IssueFormatter {
 
       // 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) as any;
+      const data = structuredClone(details) as unknown as Record<string, unknown>;
 
       let uid;
       let request: number | string | undefined;
@@ -111,7 +182,8 @@ export class IssueFormatter {
           );
           if (resolvedId) {
             request = resolvedId;
-            delete data.request.requestId;
+            const requestData = data.request as Record<string, unknown>;
+            delete requestData.requestId;
           }
         }
       }
@@ -125,31 +197,7 @@ export class IssueFormatter {
         request,
       });
     }
-    if (affectedResources.length) {
-      bodyParts.push('### Affected resources');
-      bodyParts.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(' ');
-        }),
-      );
-    }
-
-    result.push(`Message: issue> ${bodyParts.join('\n')}`);
-
-    return result.join('\n');
+    return affectedResources;
   }
 
   isValid(): boolean {

tests/formatters/ConsoleFormatter.test.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import assert from 'node:assert';
 import {describe, it} from 'node:test';
 
 import {ConsoleFormatter} from '../../src/formatters/ConsoleFormatter.js';
@@ -163,4 +164,77 @@ describe('ConsoleFormatter', () => {
       t.assert.snapshot?.(result);
     });
   });
+  describe('toJSON', () => {
+    it('formats a console.log message', async () => {
+      const message = createMockMessage({
+        type: () => 'log',
+        text: () => 'Hello, world!',
+      });
+      const result = (await ConsoleFormatter.from(message, {id: 1})).toJSON();
+      assert.deepStrictEqual(result, {
+        type: 'log',
+        text: 'Hello, world!',
+        argsCount: 0,
+        id: 1,
+      });
+    });
+
+    it('formats a console.log message with args', async () => {
+      const message = createMockMessage({
+        type: () => 'log',
+        text: () => 'Processing file:',
+        args: () => [
+          {jsonValue: async () => 'file.txt'},
+          {jsonValue: async () => 'another file'},
+        ],
+      });
+      const result = (await ConsoleFormatter.from(message, {id: 1})).toJSON();
+      assert.deepStrictEqual(result, {
+        type: 'log',
+        text: 'Processing file:',
+        argsCount: 2,
+        id: 1,
+      });
+    });
+  });
+
+  describe('toJSONDetailed', () => {
+    it('formats a console.log message', async () => {
+      const message = createMockMessage({
+        type: () => 'log',
+        text: () => 'Hello, world!',
+      });
+      const result = (
+        await ConsoleFormatter.from(message, {id: 1})
+      ).toJSONDetailed();
+      assert.deepStrictEqual(result, {
+        id: 1,
+        type: 'log',
+        text: 'Hello, world!',
+        args: [],
+        stackTrace: undefined,
+      });
+    });
+
+    it('formats a console.log message with args', async () => {
+      const message = createMockMessage({
+        type: () => 'log',
+        text: () => 'Processing file:',
+        args: () => [
+          {jsonValue: async () => 'file.txt'},
+          {jsonValue: async () => 'another file'},
+        ],
+      });
+      const result = (
+        await ConsoleFormatter.from(message, {id: 2, fetchDetailedData: true})
+      ).toJSONDetailed();
+      assert.deepStrictEqual(result, {
+        id: 2,
+        type: 'log',
+        text: 'Processing file:',
+        args: ['file.txt', 'another file'],
+        stackTrace: undefined,
+      });
+    });
+  });
 });

tests/formatters/IssueFormatter.test.ts

@@ -9,7 +9,10 @@ import {describe, it, beforeEach, afterEach} from 'node:test';
 
 import sinon from 'sinon';
 
-import {IssueFormatter} from '../../src/formatters/IssueFormatter.js';
+import {
+  IssueFormatter,
+  type IssueFormatterJsonDetailed,
+} from '../../src/formatters/IssueFormatter.js';
 import {ISSUE_UTILS} from '../../src/issue-descriptions.js';
 import {getMockAggregatedIssue} from '../utils.js';
 
@@ -134,4 +137,74 @@ describe('IssueFormatter', () => {
       assert.ok(detailed.includes('Valid Title'));
     });
   });
+  describe('toJSON', () => {
+    it('formats a simplified issue', () => {
+      const mockAggregatedIssue = getMockAggregatedIssue();
+      mockAggregatedIssue.getDescription.returns({
+        file: 'mock.md',
+        links: [],
+      });
+      mockAggregatedIssue.getAggregatedIssuesCount.returns(5);
+      getIssueDescriptionStub
+        .withArgs('mock.md')
+        .returns('# Issue Title\n\nIssue content');
+
+      const formatter = new IssueFormatter(mockAggregatedIssue, {id: 1});
+      assert.deepStrictEqual(formatter.toJSON(), {
+        type: 'issue',
+        title: 'Issue Title',
+        count: 5,
+        id: 1,
+      });
+    });
+  });
+
+  describe('toJSONDetailed', () => {
+    it('formats a detailed issue', () => {
+      const testGenericIssue = {
+        details: () => {
+          return {
+            violatingNodeId: 2,
+            violatingNodeAttribute: 'test',
+          };
+        },
+      };
+      const mockAggregatedIssue = getMockAggregatedIssue();
+      const mockDescription = {
+        file: 'mock.md',
+        links: [{link: 'http://example.com', linkTitle: 'Link 1'}],
+        substitutions: new Map([['PLACEHOLDER_VALUE', 'sub value']]),
+      };
+      mockAggregatedIssue.getDescription.returns(mockDescription);
+
+      mockAggregatedIssue.getAllIssues.returns([testGenericIssue] as any);
+
+      const mockDescriptionFileContent =
+        '# Mock Issue Title\n\nThis is a mock issue description {PLACEHOLDER_VALUE}';
+
+      getIssueDescriptionStub
+        .withArgs('mock.md')
+        .returns(mockDescriptionFileContent);
+
+      const formatter = new IssueFormatter(mockAggregatedIssue, {
+        id: 5,
+      });
+
+      const result = formatter.toJSONDetailed();
+      const detailedResult = result as IssueFormatterJsonDetailed;
+      assert.strictEqual(detailedResult.id, 5);
+      assert.strictEqual(detailedResult.type, 'issue');
+      assert.strictEqual(detailedResult.title, 'Mock Issue Title');
+      assert.strictEqual(
+        detailedResult.description,
+        '# Mock Issue Title\n\nThis is a mock issue description sub value',
+      );
+      assert.deepStrictEqual(detailedResult.links, mockDescription.links);
+      assert.strictEqual(detailedResult.affectedResources.length, 1);
+      assert.deepStrictEqual(detailedResult.affectedResources[0].data, {
+        violatingNodeAttribute: 'test',
+        violatingNodeId: 2,
+      });
+    });
+  });
 });