Chrome DevTools for coding agents
fix(console): describe Map, Set, function, DOM node, symbol and cyclic arguments (#3199)
nancy968e4e5c5042
diff --git a/src/formatters/ConsoleFormatter.ts b/src/formatters/ConsoleFormatter.tsindex 77bf29de..051536aa 100644--- a/src/formatters/ConsoleFormatter.ts+++ b/src/formatters/ConsoleFormatter.ts@@ -11,9 +11,10 @@ import {} from '../devtools/DevtoolsUtils.js';import {UncaughtError} from '../collectors/PageCollector.js';import * as DevTools from '../third_party/index.js';-import type {ConsoleMessage} from '../third_party/index.js';+import type {ConsoleMessage, Protocol} from '../third_party/index.js';import type {IssueFormatter} from './IssueFormatter.js';+import {formatRemoteObject} from './RemoteObjectFormatter.js';export interface ConsoleFormatterOptions {fetchDetailedData?: boolean;@@ -48,6 +49,23 @@ interface ConsoleMessageDetailed extends ConsoleMessageConcise {stackTrace?: string;}+// JSON.stringify prints Map, Set, functions and DOM nodes as `{}`, and throws+// on symbols and cyclic objects. Those are formatted from their preview.+function isJsonLike(remoteObject: Protocol.Runtime.RemoteObject): boolean {+ if (remoteObject.type === 'object') {+ return (+ remoteObject.subtype === undefined ||+ remoteObject.subtype === 'array' ||+ remoteObject.subtype === 'null'+ );+ }+ return (+ remoteObject.type !== 'function' &&+ remoteObject.type !== 'symbol' &&+ remoteObject.type !== 'bigint'+ );+}+export class ConsoleFormatter {readonly #id: number;readonly #type: string;@@ -152,7 +170,19 @@ export class ConsoleFormatter {targetId: msg._targetId(),});}- return await arg.jsonValue();+ if (!isJsonLike(remoteObject)) {+ return formatRemoteObject(remoteObject);+ }+ try {+ return await arg.jsonValue();+ } catch (error) {+ // JSON can't represent the value (for example, a cyclic object)+ // or the page is gone; the preview still describes it.+ if (remoteObject.preview) {+ return formatRemoteObject(remoteObject);+ }+ throw error;+ }} catch {return `<error: Argument ${i} is no longer available>`;}diff --git a/src/formatters/RemoteObjectFormatter.ts b/src/formatters/RemoteObjectFormatter.tsnew file mode 100644index 00000000..6d633896--- /dev/null+++ b/src/formatters/RemoteObjectFormatter.ts@@ -0,0 +1,277 @@+/**+ * @license+ * Copyright 2026 Google LLC+ * SPDX-License-Identifier: Apache-2.0+ */++/**+ * Plain-text port of devtools-frontend's RemoteObjectPreviewFormatter+ * (front_end/ui/legacy/components/object_ui/RemoteObjectPreviewFormatter.ts)+ * at revision f7e7785de52d6f5955d6a9c5956c2fe2d520d091, the+ * third_party/devtools-frontend revision this port was written against. Compare+ * with that file when syncing. It formats the preview that CDP already attaches+ * to console arguments, so nothing is evaluated in the page.+ *+ * Intentional differences from upstream:+ * - Returns plain text instead of Lit templates, so there are no CSS classes,+ * tooltips or localized strings ('empty' and 'empty × N' are English).+ * - No nodeDescription markup: DOM nodes print their description as is instead+ * of splitting it into tag, id and class spans (renderNodeTitle), and trusted+ * types print their description instead of `ClassName "value"`.+ * - 'date' and 'node' are added to the subtypes that print their description+ * instead of a property preview.+ * - The `includeNullOrUndefined` option is dropped; null and undefined+ * properties are always listed.+ * - Top-level strings print as their raw value (as the console does for string+ * arguments), and unserializable primitives (NaN, -0, 1n) print from+ * `unserializableValue`.+ * - The 400-character description limit that upstream passes to+ * trimEndWithMaxLength() inline is named MAX_DESCRIPTION_LENGTH.+ */++import {DevTools} from '../third_party/index.js';+import type {Protocol} from '../third_party/index.js';++const {StringUtilities} = DevTools.Platform;++const MAX_DESCRIPTION_LENGTH = 400;++const PROMISE_STATE = '[[PromiseState]]';+const PROMISE_RESULT = '[[PromiseResult]]';+const GENERATOR_STATE = '[[GeneratorState]]';+const PRIMITIVE_VALUE = '[[PrimitiveValue]]';+const WEAK_REF_TARGET = '[[WeakRefTarget]]';++// Subtypes whose description is shown instead of a property preview.+const SUBTYPES_WITHOUT_VALUE_PREVIEW = new Set<string>([+ 'arraybuffer',+ 'dataview',+ 'date',+ 'error',+ 'internal#entry',+ 'null',+ 'node',+ 'regexp',+ 'trustedtype',+ 'webassemblymemory',+]);++function sortValue(property: Protocol.Runtime.PropertyPreview): number {+ switch (property.name) {+ case PROMISE_STATE:+ return 1;+ case PROMISE_RESULT:+ return 2;+ case GENERATOR_STATE:+ case PRIMITIVE_VALUE:+ case WEAK_REF_TARGET:+ return 3;+ }+ if (property.type !== 'function' && !property.name.startsWith('#')) {+ return 4;+ }+ return 5;+}++function formatName(name: string): string {+ return /^\s|\s$|^$|\n/.test(name) ? `"${name.replace(/\n/g, '↵')}"` : name;+}++function abbreviateClassName(description: string): string {+ const parts = description.split('.');+ if (parts.length === 1 && parts[0] === 'Object') {+ return '{…}';+ }+ return parts+ .map((part, i) =>+ i < parts.length - 1 ? StringUtilities.trimMiddle(part, 3) : part,+ )+ .join('.');+}++function formatPropertyValue(+ type: string,+ subtype: string | undefined,+ description = '',+): string {+ switch (type) {+ case 'accessor':+ return '(...)';+ case 'function':+ return 'ƒ';+ case 'string':+ return StringUtilities.formatAsJSLiteral(description);+ case 'object':+ return subtype ? description : abbreviateClassName(description);+ default:+ return description;+ }+}++function arrayLength(preview: Protocol.Runtime.ObjectPreview): number {+ const match = preview.description?.match(/[[(](\d+)[\])]$/);+ return match ? Number(match[1]) : 0;+}++function formatArrayItems(preview: Protocol.Runtime.ObjectPreview): string[] {+ const length = arrayLength(preview);+ const toIndex = (name: string): number => {+ const index = Number(name) >>> 0;+ return String(index) === name && index < length ? index : -1;+ };+ const indexed = preview.properties+ .filter(p => toIndex(p.name) !== -1)+ .sort((a, b) => toIndex(a.name) - toIndex(b.name));+ const others = preview.properties+ .filter(p => toIndex(p.name) === -1)+ .sort((a, b) => sortValue(a) - sortValue(b));++ // Gaps can be shown when all properties are guaranteed to be in the preview.+ const canShowGaps = !preview.overflow;+ const gap = (count: number): string =>+ count === 1 ? 'empty' : `empty × ${count}`;+ const items: string[] = [];+ let previous = -1;+ for (const property of indexed) {+ const index = toIndex(property.name);+ const value = formatPropertyValue(+ property.type,+ property.subtype,+ property.value,+ );+ if (canShowGaps) {+ if (index - previous > 1) {+ items.push(gap(index - previous - 1));+ }+ items.push(value);+ } else {+ items.push(index === items.length ? value : `${property.name}: ${value}`);+ }+ previous = index;+ }+ if (canShowGaps && length - previous > 1) {+ items.push(gap(length - previous - 1));+ }+ for (const property of others) {+ items.push(+ `${formatName(property.name)}: ${formatPropertyValue(property.type, property.subtype, property.value)}`,+ );+ }+ return items;+}++function formatObjectItems(preview: Protocol.Runtime.ObjectPreview): string[] {+ const properties = preview.properties+ .filter(p => p.type !== 'accessor')+ .sort((a, b) => sortValue(a) - sortValue(b));+ const items: string[] = [];+ for (let i = 0; i < properties.length; i++) {+ const property = properties[i];+ const value = formatPropertyValue(+ property.type,+ property.subtype,+ property.value,+ );+ if (preview.subtype === 'promise' && property.name === PROMISE_STATE) {+ const result = properties.at(i + 1);+ if (result?.name === PROMISE_RESULT) {+ i++;+ }+ items.push(+ property.value !== 'pending' && result?.name === PROMISE_RESULT+ ? `<${property.value}>: ${formatPropertyValue(result.type, result.subtype, result.value)}`+ : `<${property.value}>`,+ );+ } else if (+ preview.subtype === 'generator' &&+ property.name === GENERATOR_STATE+ ) {+ items.push(`<${property.value}>`);+ } else if (property.name === PRIMITIVE_VALUE) {+ items.push(value);+ } else if (property.name === WEAK_REF_TARGET) {+ items.push(property.type === 'undefined' ? '<cleared>' : value);+ } else {+ items.push(`${formatName(property.name)}: ${value}`);+ }+ }+ return items;+}++function formatEntryItems(preview: Protocol.Runtime.ObjectPreview): string[] {+ return (preview.entries ?? []).map(({key, value}) => {+ const formattedValue = formatPropertyValue(+ value.type,+ value.subtype,+ value.description,+ );+ return key+ ? `${formatPropertyValue(key.type, key.subtype, key.description)} => ${formattedValue}`+ : formattedValue;+ });+}++/**+ * Formats a `Runtime.ObjectPreview` the way the DevTools console previews it,+ * for example `Map(1) {1 => 2}`, `(3) [1, 2, 3]` or `{a: 1, self: {…}}`.+ */+function formatObjectPreview(preview: Protocol.Runtime.ObjectPreview): string {+ const description = preview.description ?? '';+ if (+ preview.type !== 'object' ||+ (preview.subtype && SUBTYPES_WITHOUT_VALUE_PREVIEW.has(preview.subtype))+ ) {+ return formatPropertyValue(preview.type, preview.subtype, description);+ }+ const isArray =+ preview.subtype === 'array' || preview.subtype === 'typedarray';+ let prefix = '';+ if (isArray) {+ const length = arrayLength(preview);+ const lengthText = length > 1 ? `(${length})` : '';+ const name = description.replace(/[[(]\d+[\])]$/, '');+ prefix = name === 'Array' ? lengthText : `${name}${lengthText}`;+ } else if (description !== 'Object') {+ prefix = description;+ }+ const items = preview.entries+ ? formatEntryItems(preview)+ : isArray+ ? formatArrayItems(preview)+ : formatObjectItems(preview);+ if (preview.overflow) {+ items.push('…');+ }+ const body = isArray ? `[${items.join(', ')}]` : `{${items.join(', ')}}`;+ return prefix ? `${prefix} ${body}` : body;+}++/**+ * Formats a console argument from the description and preview that CDP sends+ * with it.+ */+export function formatRemoteObject(+ remoteObject: Protocol.Runtime.RemoteObject,+): string {+ if (+ remoteObject.preview &&+ remoteObject.type === 'object' &&+ remoteObject.subtype !== 'node' &&+ remoteObject.subtype !== 'trustedtype'+ ) {+ return formatObjectPreview(remoteObject.preview);+ }+ if (remoteObject.type === 'string') {+ return String(remoteObject.value ?? '');+ }+ if (remoteObject.unserializableValue !== undefined) {+ return remoteObject.unserializableValue;+ }+ if (remoteObject.description !== undefined) {+ return StringUtilities.trimEndWithMaxLength(+ remoteObject.description,+ MAX_DESCRIPTION_LENGTH,+ );+ }+ return String(remoteObject.value);+}diff --git a/tests/formatters/ConsoleFormatter.test.ts b/tests/formatters/ConsoleFormatter.test.tsindex f46ab9bb..304b94cf 100644--- a/tests/formatters/ConsoleFormatter.test.ts+++ b/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 {SymbolizedError} from '../../src/devtools/DevtoolsUtils.js';@@ -850,3 +851,98 @@ describe('ConsoleFormatter', () => {);});});++describe('ConsoleFormatter arguments', () => {+ it('formats non-JSON arguments from their preview and keeps JSON for plain values', async () => {+ const message = createMockMessage({+ type: () => 'log',+ text: () => 'values',+ args: () => [+ {+ jsonValue: async () => ({}),+ remoteObject: () => ({+ type: 'object',+ subtype: 'map',+ description: 'Map(1)',+ preview: {+ type: 'object',+ subtype: 'map',+ description: 'Map(1)',+ overflow: false,+ properties: [{name: 'size', type: 'number', value: '1'}],+ entries: [+ {+ key: {+ type: 'number',+ description: '1',+ overflow: false,+ properties: [],+ },+ value: {+ type: 'number',+ description: '2',+ overflow: false,+ properties: [],+ },+ },+ ],+ },+ }),+ },+ {+ jsonValue: async () => {+ throw new Error('Object reference chain is too long');+ },+ remoteObject: () => ({+ type: 'object',+ description: 'Object',+ preview: {+ type: 'object',+ description: 'Object',+ overflow: false,+ properties: [+ {name: 'name', type: 'string', value: 'cyc'},+ {name: 'self', type: 'object', value: 'Object'},+ ],+ },+ }),+ },+ {+ jsonValue: async () => ({a: 1}),+ remoteObject: () => ({type: 'object'}),+ },+ ],+ });+ const formatter = await ConsoleFormatter.from(message, {+ id: 1,+ fetchDetailedData: true,+ });+ assert.deepStrictEqual(formatter.toJSONDetailed().args, [+ 'Map(1) {1 => 2}',+ "{name: 'cyc', self: {…}}",+ '{"a":1}',+ ]);+ });++ it('reports an argument without a preview whose jsonValue() fails as unavailable', async () => {+ const message = createMockMessage({+ type: () => 'log',+ text: () => 'gone',+ args: () => [+ {+ jsonValue: async () => {+ throw new Error('Execution context was destroyed');+ },+ remoteObject: () => ({type: 'object', description: 'Object'}),+ },+ ],+ });+ const formatter = await ConsoleFormatter.from(message, {+ id: 1,+ fetchDetailedData: true,+ });+ assert.deepStrictEqual(formatter.toJSONDetailed().args, [+ '<error: Argument 0 is no longer available>',+ ]);+ });+});diff --git a/tests/formatters/RemoteObjectFormatter.test.ts b/tests/formatters/RemoteObjectFormatter.test.tsnew file mode 100644index 00000000..79e90c4f--- /dev/null+++ b/tests/formatters/RemoteObjectFormatter.test.ts@@ -0,0 +1,178 @@+/**+ * @license+ * Copyright 2026 Google LLC+ * SPDX-License-Identifier: Apache-2.0+ */++import assert from 'node:assert';+import {describe, it} from 'node:test';++import {formatRemoteObject} from '../../src/formatters/RemoteObjectFormatter.js';+import type {Protocol} from '../../src/third_party/index.js';++function preview(+ subtype: Protocol.Runtime.ObjectPreview['subtype'],+ description: string,+ properties: Protocol.Runtime.PropertyPreview[],+ {+ overflow = false,+ entries,+ }: {overflow?: boolean; entries?: Protocol.Runtime.EntryPreview[]} = {},+): Protocol.Runtime.RemoteObject {+ return {+ type: 'object',+ subtype,+ description,+ preview: {+ type: 'object',+ subtype,+ description,+ overflow,+ properties,+ entries,+ },+ };+}++describe('formatRemoteObject', () => {+ it('formats Map and Set entries', () => {+ const number = (value: string): Protocol.Runtime.ObjectPreview => ({+ type: 'number',+ description: value,+ overflow: false,+ properties: [],+ });+ const map = preview(+ 'map',+ 'Map(1)',+ [{name: 'size', type: 'number', value: '1'}],+ {+ entries: [+ {+ key: number('1'),+ value: {+ type: 'object',+ description: 'Object',+ overflow: false,+ properties: [{name: 'a', type: 'number', value: '2'}],+ },+ },+ ],+ },+ );+ assert.strictEqual(formatRemoteObject(map), 'Map(1) {1 => {…}}');++ const set = preview(+ 'set',+ 'Set(2)',+ [{name: 'size', type: 'number', value: '2'}],+ {+ entries: [+ {value: number('3')},+ {+ value: {+ type: 'string',+ description: 'x',+ overflow: false,+ properties: [],+ },+ },+ ],+ },+ );+ assert.strictEqual(formatRemoteObject(set), "Set(2) {3, 'x'}");+ });++ it('formats objects without following cycles', () => {+ assert.strictEqual(+ formatRemoteObject(+ preview(undefined, 'Object', [+ {name: 'name', type: 'string', value: 'cyc'},+ {name: 'self', type: 'object', value: 'Object'},+ {name: 'fn', type: 'function', value: ''},+ ]),+ ),+ "{name: 'cyc', self: {…}, fn: ƒ}",+ );+ });++ it('formats arrays with holes and overflow', () => {+ assert.strictEqual(+ formatRemoteObject(+ preview('array', 'Array(3)', [+ {name: '0', type: 'number', value: '1'},+ {name: '2', type: 'number', value: '3'},+ ]),+ ),+ '(3) [1, empty, 3]',+ );+ assert.strictEqual(+ formatRemoteObject(+ preview(+ 'array',+ 'Array(120)',+ [+ {name: '0', type: 'number', value: '0'},+ {name: '1', type: 'number', value: '1'},+ ],+ {overflow: true},+ ),+ ),+ '(120) [0, 1, …]',+ );+ assert.strictEqual(+ formatRemoteObject(+ preview('typedarray', 'Uint8Array(2)', [+ {name: '0', type: 'number', value: '1'},+ {name: '1', type: 'number', value: '2'},+ ]),+ ),+ 'Uint8Array(2) [1, 2]',+ );+ });++ it('formats promise state', () => {+ assert.strictEqual(+ formatRemoteObject(+ preview('promise', 'Promise', [+ {name: '[[PromiseState]]', type: 'string', value: 'fulfilled'},+ {name: '[[PromiseResult]]', type: 'number', value: '5'},+ ]),+ ),+ 'Promise {<fulfilled>: 5}',+ );+ });++ it('uses the description for values without a property preview', () => {+ assert.strictEqual(+ formatRemoteObject(+ preview('date', 'Thu Jan 01 1970 00:00:00 GMT+0000', []),+ ),+ 'Thu Jan 01 1970 00:00:00 GMT+0000',+ );+ assert.strictEqual(+ formatRemoteObject(preview('node', 'body', [], {overflow: true})),+ 'body',+ );+ assert.strictEqual(+ formatRemoteObject({+ type: 'function',+ className: 'Function',+ description: 'function foo(){ return 1; }',+ }),+ 'function foo(){ return 1; }',+ );+ assert.strictEqual(+ formatRemoteObject({type: 'symbol', description: 'Symbol(s)'}),+ 'Symbol(s)',+ );+ assert.strictEqual(+ formatRemoteObject({+ type: 'bigint',+ unserializableValue: '10n',+ description: '10n',+ }),+ '10n',+ );+ });+});