chrome-devtools-mcp 0.10.1 → 0.11.0

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/marked/package/src/rules.js

@@ -0,0 +1,243 @@
+import { edit, merge, noopTest } from './helpers.js';
+/**
+ * Block-Level Grammar
+ */
+export const block = {
+    newline: /^(?: *(?:\n|$))+/,
+    code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
+    fences: /^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?=\n|$)|$)/,
+    hr: /^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,
+    heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,
+    blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
+    list: /^( {0,3}bull)( [^\n]+?)?(?:\n|$)/,
+    html: '^ {0,3}(?:' // optional indentation
+        + '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
+        + '|comment[^\\n]*(\\n+|$)' // (2)
+        + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
+        + '|<![A-Z][\\s\\S]*?(?:>\\n*|$)' // (4)
+        + '|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)' // (5)
+        + '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (6)
+        + '|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) open tag
+        + '|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) closing tag
+        + ')',
+    def: /^ {0,3}\[(label)\]: *\n? *<?([^\s>]+)>?(?:(?: +\n? *| *\n *)(title))? *(?:\n+|$)/,
+    table: noopTest,
+    lheading: /^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/,
+    // regex template, placeholders will be replaced according to different paragraph
+    // interruption rules of commonmark and the original markdown spec:
+    _paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html| +\n)[^\n]+)*)/,
+    text: /^[^\n]+/
+};
+block._label = /(?!\s*\])(?:\\[\[\]]|[^\[\]])+/;
+block._title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
+block.def = edit(block.def)
+    .replace('label', block._label)
+    .replace('title', block._title)
+    .getRegex();
+block.bullet = /(?:[*+-]|\d{1,9}[.)])/;
+block.listItemStart = edit(/^( *)(bull) */)
+    .replace('bull', block.bullet)
+    .getRegex();
+block.list = edit(block.list)
+    .replace(/bull/g, block.bullet)
+    .replace('hr', '\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))')
+    .replace('def', '\\n+(?=' + block.def.source + ')')
+    .getRegex();
+block._tag = 'address|article|aside|base|basefont|blockquote|body|caption'
+    + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption'
+    + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe'
+    + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option'
+    + '|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr'
+    + '|track|ul';
+block._comment = /<!--(?!-?>)[\s\S]*?(?:-->|$)/;
+block.html = edit(block.html, 'i')
+    .replace('comment', block._comment)
+    .replace('tag', block._tag)
+    .replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/)
+    .getRegex();
+block.paragraph = edit(block._paragraph)
+    .replace('hr', block.hr)
+    .replace('heading', ' {0,3}#{1,6} ')
+    .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
+    .replace('blockquote', ' {0,3}>')
+    .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
+    .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+    .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)')
+    .replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
+    .getRegex();
+block.blockquote = edit(block.blockquote)
+    .replace('paragraph', block.paragraph)
+    .getRegex();
+/**
+ * Normal Block Grammar
+ */
+block.normal = merge({}, block);
+/**
+ * GFM Block Grammar
+ */
+block.gfm = merge({}, block.normal, {
+    table: '^ *([^\\n ].*\\|.*)\\n' // Header
+        + ' {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?' // Align
+        + '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)' // Cells
+});
+block.gfm.table = edit(block.gfm.table)
+    .replace('hr', block.hr)
+    .replace('heading', ' {0,3}#{1,6} ')
+    .replace('blockquote', ' {0,3}>')
+    .replace('code', ' {4}[^\\n]')
+    .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
+    .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+    .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)')
+    .replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
+    .getRegex();
+/**
+ * Pedantic grammar (original John Gruber's loose markdown specification)
+ */
+block.pedantic = merge({}, block.normal, {
+    html: edit('^ *(?:comment *(?:\\n|\\s*$)'
+        + '|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)' // closed tag
+        + '|<tag(?:"[^"]*"|\'[^\']*\'|\\s[^\'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))')
+        .replace('comment', block._comment)
+        .replace(/tag/g, '(?!(?:'
+        + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub'
+        + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)'
+        + '\\b)\\w+(?!:|[^\\w\\s@]*@)\\b')
+        .getRegex(),
+    def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
+    heading: /^(#{1,6})(.*)(?:\n+|$)/,
+    fences: noopTest, // fences not supported
+    paragraph: edit(block.normal._paragraph)
+        .replace('hr', block.hr)
+        .replace('heading', ' *#{1,6} *[^\n]')
+        .replace('lheading', block.lheading)
+        .replace('blockquote', ' {0,3}>')
+        .replace('|fences', '')
+        .replace('|list', '')
+        .replace('|html', '')
+        .getRegex()
+});
+/**
+ * Inline-Level Grammar
+ */
+export const inline = {
+    escape: /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,
+    autolink: /^<(scheme:[^\s\x00-\x1f<>]*|email)>/,
+    url: noopTest,
+    tag: '^comment'
+        + '|^</[a-zA-Z][\\w:-]*\\s*>' // self-closing tag
+        + '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
+        + '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g. <?php ?>
+        + '|^<![a-zA-Z]+\\s[\\s\\S]*?>' // declaration, e.g. <!DOCTYPE html>
+        + '|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>', // CDATA section
+    link: /^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,
+    reflink: /^!?\[(label)\]\[(?!\s*\])((?:\\[\[\]]?|[^\[\]\\])+)\]/,
+    nolink: /^!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,
+    reflinkSearch: 'reflink|nolink(?!\\()',
+    emStrong: {
+        lDelim: /^(?:\*+(?:([punct_])|[^\s*]))|^_+(?:([punct*])|([^\s_]))/,
+        //        (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.
+        //        () Skip orphan delim inside strong    (1) #***                (2) a***#, a***                   (3) #***a, ***a                 (4) ***#              (5) #***#                 (6) a***a
+        rDelimAst: /^[^_*]*?\_\_[^_*]*?\*[^_*]*?(?=\_\_)|[punct_](\*+)(?=[\s]|$)|[^punct*_\s](\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|[^punct*_\s](\*+)(?=[^punct*_\s])/,
+        rDelimUnd: /^[^_*]*?\*\*[^_*]*?\_[^_*]*?(?=\*\*)|[punct*](\_+)(?=[\s]|$)|[^punct*_\s](\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/ // ^- Not allowed for _
+    },
+    code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
+    br: /^( {2,}|\\)\n(?!\s*$)/,
+    del: noopTest,
+    text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,
+    punctuation: /^([\spunctuation])/
+};
+// list of punctuation marks from CommonMark spec
+// without * and _ to handle the different emphasis markers * and _
+inline._punctuation = '!"#$%&\'()+\\-.,/:;<=>?@\\[\\]`^{|}~';
+inline.punctuation = edit(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex();
+// sequences em should skip over [title](link), `code`, <html>
+inline.blockSkip = /\[[^\]]*?\]\([^\)]*?\)|`[^`]*?`|<[^>]*?>/g;
+inline.escapedEmSt = /\\\*|\\_/g;
+inline._comment = edit(block._comment).replace('(?:-->|$)', '-->').getRegex();
+inline.emStrong.lDelim = edit(inline.emStrong.lDelim)
+    .replace(/punct/g, inline._punctuation)
+    .getRegex();
+inline.emStrong.rDelimAst = edit(inline.emStrong.rDelimAst, 'g')
+    .replace(/punct/g, inline._punctuation)
+    .getRegex();
+inline.emStrong.rDelimUnd = edit(inline.emStrong.rDelimUnd, 'g')
+    .replace(/punct/g, inline._punctuation)
+    .getRegex();
+inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g;
+inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;
+inline._email = /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/;
+inline.autolink = edit(inline.autolink)
+    .replace('scheme', inline._scheme)
+    .replace('email', inline._email)
+    .getRegex();
+inline._attribute = /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/;
+inline.tag = edit(inline.tag)
+    .replace('comment', inline._comment)
+    .replace('attribute', inline._attribute)
+    .getRegex();
+inline._label = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+inline._href = /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/;
+inline._title = /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/;
+inline.link = edit(inline.link)
+    .replace('label', inline._label)
+    .replace('href', inline._href)
+    .replace('title', inline._title)
+    .getRegex();
+inline.reflink = edit(inline.reflink)
+    .replace('label', inline._label)
+    .getRegex();
+inline.reflinkSearch = edit(inline.reflinkSearch, 'g')
+    .replace('reflink', inline.reflink)
+    .replace('nolink', inline.nolink)
+    .getRegex();
+/**
+ * Normal Inline Grammar
+ */
+inline.normal = merge({}, inline);
+/**
+ * Pedantic Inline Grammar
+ */
+inline.pedantic = merge({}, inline.normal, {
+    strong: {
+        start: /^__|\*\*/,
+        middle: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
+        endAst: /\*\*(?!\*)/g,
+        endUnd: /__(?!_)/g
+    },
+    em: {
+        start: /^_|\*/,
+        middle: /^()\*(?=\S)([\s\S]*?\S)\*(?!\*)|^_(?=\S)([\s\S]*?\S)_(?!_)/,
+        endAst: /\*(?!\*)/g,
+        endUnd: /_(?!_)/g
+    },
+    link: edit(/^!?\[(label)\]\((.*?)\)/)
+        .replace('label', inline._label)
+        .getRegex(),
+    reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/)
+        .replace('label', inline._label)
+        .getRegex()
+});
+/**
+ * GFM Inline Grammar
+ */
+inline.gfm = merge({}, inline.normal, {
+    escape: edit(inline.escape).replace('])', '~|])').getRegex(),
+    _extended_email: /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,
+    url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
+    _backpedal: /(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,
+    del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
+    text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
+});
+inline.gfm.url = edit(inline.gfm.url, 'i')
+    .replace('email', inline.gfm._extended_email)
+    .getRegex();
+/**
+ * GFM + Line Breaks Inline Grammar
+ */
+inline.breaks = merge({}, inline.gfm, {
+    br: edit(inline.br).replace('{2,}', '*').getRegex(),
+    text: edit(inline.gfm.text)
+        .replace('\\b_', '\\b_| {2,}\\n')
+        .replace(/\{2,\}/g, '*')
+        .getRegex()
+});

package/build/node_modules/chrome-devtools-frontend/mcp/HostBindings.js

@@ -0,0 +1,222 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { readFile } from 'node:fs/promises';
+import { URL } from 'node:url';
+import { streamWrite } from '../front_end/core/host/ResourceLoader.js';
+export class McpHostBindings {
+    connectAutomaticFileSystem() {
+    }
+    disconnectAutomaticFileSystem() {
+    }
+    addFileSystem() {
+    }
+    loadCompleted() {
+    }
+    indexPath() {
+    }
+    setInspectedPageBounds() {
+    }
+    showCertificateViewer() {
+    }
+    setWhitelistedShortcuts() {
+    }
+    setEyeDropperActive() {
+    }
+    inspectElementCompleted() {
+    }
+    openInNewTab() {
+    }
+    openSearchResultsInNewTab() {
+    }
+    showItemInFolder() {
+    }
+    removeFileSystem() {
+    }
+    requestFileSystems() {
+    }
+    save() {
+    }
+    append() {
+    }
+    close() {
+    }
+    searchInPath() {
+    }
+    stopIndexing() {
+    }
+    bringToFront() {
+    }
+    closeWindow() {
+    }
+    copyText() {
+    }
+    inspectedURLChanged() {
+    }
+    isolatedFileSystem() {
+        return null;
+    }
+    loadNetworkResource(urlString, _headers, streamId, callback) {
+        let url;
+        try {
+            url = new URL(urlString);
+        }
+        catch {
+            callback({
+                statusCode: 404,
+                urlValid: false,
+            });
+            return;
+        }
+        let contentPromise;
+        if (url.protocol === 'file:') {
+            contentPromise = readFile(url, { encoding: 'utf8' });
+        }
+        else if (url.protocol === 'http:' || url.protocol === 'https:') {
+            // We skip parsing headers. DevTools only sets cache and user agent, which is probably fine to not forward.
+            contentPromise = fetch(url).then(response => {
+                if (!response.ok) {
+                    throw new Error('Fetch failed');
+                }
+                return response.text();
+            });
+        }
+        else {
+            // Unknown protocol.
+            callback({
+                statusCode: 404,
+                urlValid: false,
+            });
+            return;
+        }
+        contentPromise
+            .then(content => {
+            streamWrite(streamId, content);
+            callback({ statusCode: 200 });
+        })
+            .catch(() => {
+            callback({ statusCode: 404 });
+        });
+    }
+    registerPreference() {
+    }
+    getPreferences() {
+    }
+    getPreference() {
+    }
+    setPreference() {
+    }
+    removePreference() {
+    }
+    clearPreferences() {
+    }
+    getSyncInformation() {
+    }
+    getHostConfig() {
+    }
+    upgradeDraggedFileSystemPermissions() {
+    }
+    platform() {
+        switch (process.platform) {
+            case 'darwin':
+                return 'mac';
+            case 'win32':
+                return 'windows';
+            default:
+                return 'linux';
+        }
+    }
+    recordCountHistogram() {
+    }
+    recordEnumeratedHistogram() {
+    }
+    recordPerformanceHistogram() {
+    }
+    recordUserMetricsAction() {
+    }
+    recordNewBadgeUsage() {
+    }
+    sendMessageToBackend() {
+    }
+    setDevicesDiscoveryConfig() {
+    }
+    setDevicesUpdatesEnabled() {
+    }
+    openRemotePage() {
+    }
+    openNodeFrontend() {
+    }
+    setInjectedScriptForOrigin() {
+    }
+    setIsDocked() {
+    }
+    showSurvey() {
+    }
+    canShowSurvey() {
+    }
+    zoomFactor() {
+        return 1;
+    }
+    zoomIn() {
+    }
+    zoomOut() {
+    }
+    resetZoom() {
+    }
+    showContextMenuAtPoint() {
+    }
+    reattach() {
+    }
+    readyForTest() {
+    }
+    connectionReady() {
+    }
+    setOpenNewWindowForPopups() {
+    }
+    isHostedMode() {
+        return true;
+    }
+    setAddExtensionCallback() {
+    }
+    initialTargetId() {
+        return Promise.resolve(null);
+    }
+    doAidaConversation(_request, _streamId, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    registerAidaClientEvent(_request, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    aidaCodeComplete(_request, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    dispatchHttpRequest(_request, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    recordImpression() {
+    }
+    recordResize() {
+    }
+    recordClick() {
+    }
+    recordHover() {
+    }
+    recordDrag() {
+    }
+    recordChange() {
+    }
+    recordKeyDown() {
+    }
+    recordSettingAccess() {
+    }
+    recordFunctionCall() {
+    }
+}

package/build/node_modules/chrome-devtools-frontend/mcp/mcp.js

@@ -1,14 +1,35 @@
 // Copyright 2025 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+// Instantiating a DevTools universe requires settings from these meta files.
+// Until settings registration is handled differently, the easiest solution is to
+// just import relevant meta files (as long as they don't contain any UI related code)
+import '../front_end/core/sdk/sdk-meta.js';
+import '../front_end/models/workspace/workspace-meta.js';
+import { installInspectorFrontendHost } from '../front_end/core/host/InspectorFrontendHost.js';
+import { McpHostBindings } from './HostBindings.js';
 /**
  * IMPORTANT! Make sure that any class that is exported here has related unit
  * tests added to foundation_unittests. See front_end/core/i18n/BUILD.gn as an
  * example.
  */
+export * as Common from '../front_end/core/common/common.js';
 export * as I18n from '../front_end/core/i18n/i18n.js';
 export { ConnectionTransport } from '../front_end/core/protocol_client/ConnectionTransport.js';
+export * as ProtocolClient from '../front_end/core/protocol_client/protocol_client.js';
+export { DebuggerModel } from '../front_end/core/sdk/DebuggerModel.js';
+export { Target } from '../front_end/core/sdk/Target.js';
+export { TargetManager } from '../front_end/core/sdk/TargetManager.js';
+export * as Foundation from '../front_end/foundation/foundation.js';
 export { PerformanceInsightFormatter } from '../front_end/models/ai_assistance/data_formatters/PerformanceInsightFormatter.js';
 export { PerformanceTraceFormatter } from '../front_end/models/ai_assistance/data_formatters/PerformanceTraceFormatter.js';
 export { AgentFocus } from '../front_end/models/ai_assistance/performance/AIContext.js';
+export { DebuggerWorkspaceBinding } from '../front_end/models/bindings/DebuggerWorkspaceBinding.js';
+export { Issue } from '../front_end/models/issues_manager/Issue.js';
+export { AggregatedIssue, IssueAggregator } from '../front_end/models/issues_manager/IssueAggregator.js';
+export { createIssuesFromProtocolIssue, IssuesManager } from '../front_end/models/issues_manager/IssuesManager.js';
+export * as MarkdownIssueDescription from '../front_end/models/issues_manager/MarkdownIssueDescription.js';
+export * as StackTrace from '../front_end/models/stack_trace/stack_trace.js';
 export * as TraceEngine from '../front_end/models/trace/trace.js';
+export * as Marked from '../front_end/third_party/marked/marked.js';
+installInspectorFrontendHost(new McpHostBindings());

package/build/src/DevToolsConnectionAdapter.js

@@ -3,31 +3,67 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-// eslint-disable-next-line no-restricted-imports
-import { ConnectionTransport as DevToolsConnectionTransport } from '../node_modules/chrome-devtools-frontend/front_end/core/protocol_client/ConnectionTransport.js';
+import { CDPSessionEvent } from './third_party/index.js';
 /**
- * Allows a puppeteer {@link ConnectionTransport} to act like a DevTools {@link Connection}.
+ * This class makes a puppeteer connection look like DevTools CDPConnection.
+ *
+ * Since we connect "root" DevTools targets to specific pages, we scope everything to a puppeteer CDP session.
+ *
+ * We don't have to recursively listen for 'sessionattached' as the "root" CDP session sees all child session attached
+ * events, regardless how deeply nested they are.
  */
-export class DevToolsConnectionAdapter extends DevToolsConnectionTransport {
-    #transport;
-    #onDisconnect = null;
-    constructor(transport) {
-        super();
-        this.#transport = transport;
-        this.#transport.onclose = () => this.#onDisconnect?.('');
-        this.#transport.onmessage = msg => this.onMessage?.(msg);
+export class PuppeteerDevToolsConnection {
+    #connection;
+    #observers = new Set();
+    #sessionEventHandlers = new Map();
+    constructor(session) {
+        this.#connection = session.connection();
+        session.on(CDPSessionEvent.SessionAttached, this.#startForwardingCdpEvents.bind(this));
+        session.on(CDPSessionEvent.SessionDetached, this.#stopForwardingCdpEvents.bind(this));
+        this.#startForwardingCdpEvents(session);
     }
-    setOnMessage(onMessage) {
-        this.onMessage = onMessage;
+    send(method, params, sessionId) {
+        if (sessionId === undefined) {
+            throw new Error('Attempting to send on the root session. This must not happen');
+        }
+        const session = this.#connection.session(sessionId);
+        if (!session) {
+            throw new Error('Unknown session ' + sessionId);
+        }
+        // Rolled protocol version between puppeteer and DevTools doesn't necessarily match
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        return session
+            .send(method, params)
+            .then(result => ({ result }))
+            .catch(error => ({ error }));
+        /* eslint-enable @typescript-eslint/no-explicit-any */
     }
-    setOnDisconnect(onDisconnect) {
-        this.#onDisconnect = onDisconnect;
+    observe(observer) {
+        this.#observers.add(observer);
     }
-    sendRawMessage(message) {
-        this.#transport?.send(message);
+    unobserve(observer) {
+        this.#observers.delete(observer);
     }
-    async disconnect() {
-        this.#transport?.close();
-        this.#transport = null;
+    #startForwardingCdpEvents(session) {
+        const handler = this.#handleEvent.bind(this, session.id());
+        this.#sessionEventHandlers.set(session.id(), handler);
+        session.on('*', handler);
+    }
+    #stopForwardingCdpEvents(session) {
+        const handler = this.#sessionEventHandlers.get(session.id());
+        if (handler) {
+            session.off('*', handler);
+        }
+    }
+    #handleEvent(sessionId, type, event) {
+        if (typeof type === 'string' &&
+            type !== CDPSessionEvent.SessionAttached &&
+            type !== CDPSessionEvent.SessionDetached) {
+            this.#observers.forEach(observer => observer.onEvent({
+                method: type,
+                sessionId,
+                params: event,
+            }));
+        }
     }
 }