@yezack/chrome-devtools-mcp-108 0.0.0-stage → 1.10.2

package/build/src/bin/check-latest-version.js

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { execSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+function getRegistry() {
+    // Use the user's configured npm registry so update checks work behind
+    // corporate proxies and private registries. `npm config get registry`
+    // honors .npmrc files at every scope and respects npm_config_registry,
+    // so it covers direct CLI invocations as well as `npx` / `npm run`.
+    try {
+        const registry = execSync('npm config get registry', {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 5000,
+            windowsHide: true,
+        })
+            .trim()
+            .replace(/\/$/, '');
+        if (registry && registry !== 'undefined' && /^https?:\/\//.test(registry)) {
+            return registry;
+        }
+    }
+    catch {
+        // npm not on PATH or other errors, fall back to default.
+    }
+    return DEFAULT_REGISTRY;
+}
+const cachePath = process.argv[2];
+if (cachePath) {
+    try {
+        const response = await fetch(`${getRegistry()}/chrome-devtools-mcp/latest`);
+        const data = response.ok ? await response.json() : null;
+        if (data &&
+            typeof data === 'object' &&
+            'version' in data &&
+            typeof data.version === 'string') {
+            await fs.mkdir(path.dirname(cachePath), { recursive: true });
+            await fs.writeFile(cachePath, JSON.stringify({ version: data.version }));
+        }
+    }
+    catch {
+        // Ignore errors.
+    }
+}
+//# sourceMappingURL=check-latest-version.js.map

package/build/src/bin/chrome-devtools-mcp-main.js

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import '../utils/polyfill.js';
+import process from 'node:process';
+import { BrowserManager } from '../BrowserManager.js';
+import { McpServer, logDisclaimers } from '../index.js';
+import { ClearcutLogger } from '../telemetry/ClearcutLogger.js';
+import { computeFlagUsage } from '../telemetry/flagUtils.js';
+import { StdioServerTransport } from '../third_party/index.js';
+import { checkForUpdates } from '../utils/check-for-updates.js';
+import { logger, saveLogsToFile } from '../utils/logger.js';
+import { VERSION } from '../version.js';
+import { mcpOptions, parseArguments } from '../config/mcp-options.js';
+await checkForUpdates('Run `npm install chrome-devtools-mcp@latest` to update.');
+export const args = parseArguments(VERSION);
+const logFile = args.logFile ? saveLogsToFile(args.logFile) : undefined;
+if (process.env['CHROME_DEVTOOLS_MCP_CRASH_ON_UNCAUGHT'] !== 'true') {
+    process.on('unhandledRejection', (reason, promise) => {
+        logger?.('Unhandled promise rejection', promise, reason);
+    });
+}
+logger?.(`Starting Chrome DevTools MCP Server v${VERSION}`);
+const browserManager = new BrowserManager(args, {
+    logFile,
+});
+const serverPromise = McpServer.from(args, {
+    browserManager,
+});
+// Shutdown on stdin EOF (stdio MCP convention — the client closes the
+// transport to signal exit) and on standard termination signals. Without
+// this, an active Chrome subprocess keeps the Node event loop ref'd after
+// stdin closes and the server hangs until something else kills it.
+let shuttingDown = false;
+async function shutdown(reason) {
+    if (shuttingDown) {
+        return;
+    }
+    shuttingDown = true;
+    logger?.(`Shutting down (${reason})`);
+    // Backstop in case browser teardown hangs (e.g. unresponsive Chrome,
+    // slow beforeunload handlers, many tabs). Exits 0 because we still
+    // honored the shutdown request; the log line preserves observability.
+    // Unref'd so it doesn't keep the loop alive on the clean path.
+    setTimeout(() => {
+        logger?.('Shutdown timeout exceeded, forcing exit');
+        process.exit(0);
+    }, 5000).unref();
+    const server = await serverPromise;
+    await server.close();
+    process.exit(0);
+}
+process.stdin.on('end', () => {
+    void shutdown('stdin end');
+});
+process.stdin.on('close', () => {
+    void shutdown('stdin close');
+});
+process.on('SIGTERM', () => {
+    void shutdown('SIGTERM');
+});
+process.on('SIGINT', () => {
+    void shutdown('SIGINT');
+});
+process.on('SIGHUP', () => {
+    void shutdown('SIGHUP');
+});
+const server = await serverPromise;
+const transport = new StdioServerTransport();
+await server.connect(transport);
+logger?.('Chrome DevTools MCP Server connected');
+logDisclaimers(args);
+void ClearcutLogger.get()?.logDailyActiveIfNeeded();
+void ClearcutLogger.get()?.logServerStart(computeFlagUsage(args, mcpOptions));
+//# sourceMappingURL=chrome-devtools-mcp-main.js.map

package/build/src/bin/chrome-devtools-mcp.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+process.title = 'chrome-devtools-mcp';
+import { version } from 'node:process';
+const [major, minor] = version.substring(1).split('.').map(Number);
+if (major === 20 && minor < 19) {
+    console.error(`ERROR: \`chrome-devtools-mcp\` does not support Node ${process.version}. Please upgrade to Node 20.19.0 LTS or a newer LTS.`);
+    process.exit(1);
+}
+if (major === 22 && minor < 12) {
+    console.error(`ERROR: \`chrome-devtools-mcp\` does not support Node ${process.version}. Please upgrade to Node 22.12.0 LTS or a newer LTS.`);
+    process.exit(1);
+}
+if (major < 20) {
+    console.error(`ERROR: \`chrome-devtools-mcp\` does not support Node ${process.version}. Please upgrade to Node 20.19.0 LTS or a newer LTS.`);
+    process.exit(1);
+}
+await import('./chrome-devtools-mcp-main.js');
+//# sourceMappingURL=chrome-devtools-mcp.js.map

package/build/src/bin/chrome-devtools.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+process.title = 'chrome-devtools';
+import process from 'node:process';
+import { startDaemon, stopDaemon, sendCommand, handleResponse, verifyDaemonVersion, } from '../daemon/client.js';
+import { isDaemonRunning, serializeArgs, assertValidSessionId, } from '../daemon/utils.js';
+import { logDisclaimers } from '../index.js';
+import { hideBin, yargs } from '../third_party/index.js';
+import { checkForUpdates } from '../utils/check-for-updates.js';
+import { VERSION } from '../version.js';
+import { buildCommand } from '../config/cli-commands.js';
+import { commands } from '../config/cli-options.js';
+import { mcpOptions, parseArguments, getMcpOptionsForViaCli, } from '../config/mcp-options.js';
+await checkForUpdates('Run `npm install -g chrome-devtools-mcp@latest` and `chrome-devtools start` to update and restart the daemon.');
+const DEFAULT_CLI_ARGS = ['--viaCli'];
+async function start(args, sessionId) {
+    const combinedArgs = [...DEFAULT_CLI_ARGS, ...args];
+    await startDaemon(combinedArgs, sessionId);
+    logDisclaimers(parseArguments(VERSION, combinedArgs));
+}
+function getCliOptions() {
+    const options = {
+        ...getMcpOptionsForViaCli(),
+    };
+    // Missing CLI serialization.
+    delete options.viewport;
+    // Change the defaults for the CLI.
+    delete options.experimentalStructuredContent;
+    delete options.experimentalInteropTools;
+    return options;
+}
+const y = yargs(hideBin(process.argv))
+    .locale('en') // Force English to ensure error string matching works in .fail, all custom messages we output are in English anyways
+    .scriptName('chrome-devtools')
+    .showHelpOnFail(true)
+    .usage('chrome-devtools <command> [...args] --flags')
+    .usage(`Run 'chrome-devtools <command> --help' for help on the specific command.`)
+    .option('sessionId', {
+    type: 'string',
+    description: 'Session ID for daemon scoping',
+    default: process.env.CD4A_INTERNAL_DAEMON_SESSION_ID || '',
+    hidden: true,
+    coerce: (sessionId) => {
+        assertValidSessionId(sessionId);
+        return sessionId;
+    },
+})
+    .demandCommand()
+    .version(VERSION)
+    .strict()
+    .help(true)
+    .wrap(120)
+    .fail((msg, err) => {
+    if (msg) {
+        console.error('Error:', msg);
+        if (msg.includes('Not enough non-option arguments') ||
+            msg.includes('Unknown argument') ||
+            msg.includes('Unknown arguments')) {
+            console.error('\n=========================================');
+            console.error('💡 TIP FOR AI AGENT / DEVELOPER:');
+            console.error('In the `chrome-devtools` CLI:');
+            console.error('1. Required parameters MUST be passed as positional arguments (without flags).');
+            console.error('   - INCORRECT: chrome-devtools click --pageId 1 --uid "1_2"');
+            console.error('   - CORRECT:   chrome-devtools click 1 "1_2"');
+            console.error('2. Optional parameters are passed as double-dash options/flags (e.g. --dblClick true).');
+            console.error('3. Make sure to escape quotes properly for your shell environment.');
+            console.error('Run `chrome-devtools <command> --help` to see exact positional and optional parameters.');
+            console.error('=========================================');
+        }
+    }
+    else if (err) {
+        console.error(err);
+    }
+    process.exit(1);
+});
+y.command('start', 'Start or restart chrome-devtools-mcp', y => y
+    .options(getCliOptions())
+    .example('$0 start --browserUrl http://localhost:9222', 'Start the server connecting to an existing browser')
+    .strict(), async (argv) => {
+    if (isDaemonRunning(argv.sessionId)) {
+        await stopDaemon(argv.sessionId);
+    }
+    // Defaults but we do not want to affect the yargs conflict resolution.
+    if (argv.isolated === undefined &&
+        argv.userDataDir === undefined &&
+        !argv.autoConnect &&
+        !argv.browserUrl &&
+        !argv.wsEndpoint) {
+        argv.isolated = true;
+    }
+    if (argv.headless === undefined &&
+        !argv.autoConnect &&
+        !argv.browserUrl &&
+        !argv.wsEndpoint) {
+        argv.headless = true;
+    }
+    const args = serializeArgs(getCliOptions(), argv);
+    await start(args, argv.sessionId);
+    process.exit(0);
+}).strict(); // Re-enable strict validation for other commands; this is applied to the yargs instance itself
+y.command('status', 'Checks if chrome-devtools-mcp is running', y => y, async (argv) => {
+    if (isDaemonRunning(argv.sessionId)) {
+        console.log('chrome-devtools-mcp daemon is running.');
+        const response = await sendCommand({
+            method: 'status',
+        }, argv.sessionId);
+        if (response.success) {
+            const data = JSON.parse(response.result);
+            console.log(`pid=${data.pid} socket=${data.socketPath} start-date=${data.startDate} version=${data.version}`);
+            console.log(`args=${JSON.stringify(data.args)}`);
+            if (data.version !== VERSION) {
+                console.warn(`Warning: Daemon server version (${data.version}) does not match CLI version (${VERSION}). Run 'chrome-devtools start' to update and restart the daemon.`);
+            }
+        }
+        else {
+            console.error('Error:', response.error);
+            process.exit(1);
+        }
+    }
+    else {
+        console.log('chrome-devtools-mcp daemon is not running.');
+    }
+    process.exit(0);
+});
+y.command('stop', 'Stop chrome-devtools-mcp if any', y => y, async (argv) => {
+    const sessionId = argv.sessionId;
+    if (!isDaemonRunning(sessionId)) {
+        process.exit(0);
+    }
+    await stopDaemon(sessionId);
+    process.exit(0);
+});
+for (const [commandName, commandDef] of Object.entries(commands)) {
+    const args = commandDef.args;
+    const { command, usage } = buildCommand(commandName, args);
+    y.command(command, commandDef.description, y => {
+        y.usage(usage);
+        y.option('output-format', {
+            choices: ['md', 'json'],
+            default: 'md',
+        });
+        for (const [argName, opt] of Object.entries(args)) {
+            const type = opt.type === 'integer' || opt.type === 'number'
+                ? 'number'
+                : opt.type === 'boolean'
+                    ? 'boolean'
+                    : opt.type === 'array'
+                        ? 'array'
+                        : 'string';
+            if (opt.required) {
+                const options = {
+                    describe: opt.description,
+                    type: type,
+                };
+                if (opt.default !== undefined) {
+                    options.default = opt.default;
+                }
+                if (opt.enum) {
+                    options.choices = opt.enum;
+                }
+                y.positional(argName, options);
+            }
+            else {
+                const options = {
+                    describe: opt.description,
+                    type: type,
+                };
+                if (opt.default !== undefined) {
+                    options.default = opt.default;
+                }
+                if (opt.enum) {
+                    options.choices = opt.enum;
+                }
+                y.option(argName, options);
+            }
+        }
+    }, async (argv) => {
+        const sessionId = argv.sessionId;
+        try {
+            const versionWarningPromise = isDaemonRunning(sessionId)
+                ? verifyDaemonVersion(sessionId, VERSION)
+                : Promise.resolve(undefined);
+            if (!isDaemonRunning(sessionId)) {
+                await start(serializeArgs(mcpOptions, argv), sessionId);
+            }
+            const commandArgs = {};
+            for (const argName of Object.keys(args)) {
+                if (argName in argv) {
+                    commandArgs[argName] = argv[argName];
+                }
+            }
+            const response = await sendCommand({
+                method: 'invoke_tool',
+                tool: commandName,
+                args: commandArgs,
+            }, sessionId);
+            if (response.success) {
+                console.log(await handleResponse(JSON.parse(response.result), argv['output-format']));
+            }
+            else {
+                console.error('Error:', response.error);
+            }
+            const versionWarning = await versionWarningPromise;
+            if (versionWarning) {
+                console.warn(versionWarning);
+            }
+            if (!response.success) {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error('Failed to execute command:', error);
+            process.exit(1);
+        }
+    });
+}
+await y.parse();
+//# sourceMappingURL=chrome-devtools.js.map

package/build/src/collectors/PageCollector.js

@@ -0,0 +1,291 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FakeIssuesManager } from '../devtools/DevtoolsUtils.js';
+import { DevTools, FrameEvent } from '../third_party/index.js';
+import { createIdGenerator, stableIdSymbol, } from '../utils/id.js';
+import { logger } from '../utils/logger.js';
+export class UncaughtError {
+    details;
+    targetId;
+    constructor(details, targetId) {
+        this.details = details;
+        this.targetId = targetId;
+    }
+}
+export class PageCollector {
+    pptrPage;
+    #listeners;
+    #pendingSameDocumentNavigation = false;
+    #frameNavigatedWithinDocumentTarget;
+    maxNavigationSaved = 3;
+    /**
+     * This maps a Page to a list of navigations with a sub-list
+     * of all collected resources.
+     * The newer navigations come first.
+     */
+    storage = [[]];
+    constructor(page, listeners, maxResourcesPerNavigation) {
+        this.pptrPage = page;
+        this.#attachFrameNavigatedWithinDocumentListener();
+        const idGenerator = createIdGenerator();
+        const listenerMap = listeners(value => {
+            const withId = value;
+            withId[stableIdSymbol] = idGenerator();
+            this.storage[0].push(withId);
+            if (maxResourcesPerNavigation !== undefined &&
+                this.storage[0].length > maxResourcesPerNavigation) {
+                this.storage[0].splice(0, this.storage[0].length - maxResourcesPerNavigation);
+            }
+        });
+        listenerMap['framenavigated'] = (frame) => {
+            // Only split the storage on main frame navigation
+            if (frame !== this.pptrPage.mainFrame()) {
+                return;
+            }
+            // Re-attach the listener to the current main frame: a cross-document
+            // navigation may have replaced the frame object, so the reference
+            // captured at construction time would be stale.
+            this.#attachFrameNavigatedWithinDocumentListener();
+            // Same-document (SPA) navigations also emit `framenavigated`, but they
+            // must not rotate the retained history. Puppeteer emits
+            // `FrameNavigatedWithinDocument` right before `FrameNavigated` for such
+            // navigations, so consume the flag here to skip the split.
+            if (this.#pendingSameDocumentNavigation) {
+                this.#pendingSameDocumentNavigation = false;
+                return;
+            }
+            this.splitAfterNavigation();
+        };
+        for (const [name, listener] of Object.entries(listenerMap)) {
+            this.pptrPage.on(name, listener);
+        }
+        this.#listeners = listenerMap;
+    }
+    dispose() {
+        this.#detachFrameNavigatedWithinDocumentListener();
+        if (this.#listeners) {
+            for (const [name, listener] of Object.entries(this.#listeners)) {
+                this.pptrPage.off(name, listener);
+            }
+        }
+    }
+    // Puppeteer emits this right before the page-level navigation event for
+    // same-document (SPA) navigations, which lets `framenavigated` skip the
+    // history rotation for those navigations.
+    #onFrameNavigatedWithinDocument = () => {
+        this.#pendingSameDocumentNavigation = true;
+    };
+    #attachFrameNavigatedWithinDocumentListener() {
+        this.#detachFrameNavigatedWithinDocumentListener();
+        this.#frameNavigatedWithinDocumentTarget = this.pptrPage.mainFrame();
+        this.#frameNavigatedWithinDocumentTarget.on(FrameEvent.FrameNavigatedWithinDocument, this.#onFrameNavigatedWithinDocument);
+    }
+    #detachFrameNavigatedWithinDocumentListener() {
+        if (this.#frameNavigatedWithinDocumentTarget) {
+            this.#frameNavigatedWithinDocumentTarget.off(FrameEvent.FrameNavigatedWithinDocument, this.#onFrameNavigatedWithinDocument);
+            this.#frameNavigatedWithinDocumentTarget = undefined;
+        }
+    }
+    splitAfterNavigation() {
+        // Add the latest navigation first
+        this.storage.unshift([]);
+        this.storage.splice(this.maxNavigationSaved);
+    }
+    getData(includePreservedData) {
+        if (!includePreservedData) {
+            return this.storage[0];
+        }
+        const data = [];
+        for (let index = this.maxNavigationSaved; index >= 0; index--) {
+            if (this.storage[index]) {
+                data.push(...this.storage[index]);
+            }
+        }
+        return data;
+    }
+    getIdForResource(resource) {
+        return resource[stableIdSymbol] ?? -1;
+    }
+    getById(stableId) {
+        const item = this.find(item => item[stableIdSymbol] === stableId);
+        if (!item) {
+            throw new Error('Request not found for selected page');
+        }
+        return item;
+    }
+    find(filter) {
+        for (const navigation of this.storage) {
+            const item = navigation.find(filter);
+            if (item) {
+                return item;
+            }
+        }
+        return;
+    }
+}
+export class ConsoleCollector extends PageCollector {
+    static MAX_MESSAGES_PER_NAVIGATION = 10_000;
+    #subscriber;
+    constructor(page, listeners, maxMessagesPerNavigation = ConsoleCollector.MAX_MESSAGES_PER_NAVIGATION) {
+        super(page, listeners, maxMessagesPerNavigation);
+        this.#subscriber = new PageEventSubscriber(this.pptrPage);
+        this.#subscriber.subscribe();
+    }
+    dispose() {
+        super.dispose();
+        this.#subscriber?.unsubscribe();
+    }
+}
+class PageEventSubscriber {
+    #issueManager = new FakeIssuesManager();
+    #issueAggregator = new DevTools.IssueAggregator(this.#issueManager);
+    #seenKeys = new Set();
+    #seenIssues = new Set();
+    #page;
+    #session;
+    #targetId;
+    #pendingSameDocumentNavigation = false;
+    #frameNavigatedWithinDocumentTarget;
+    constructor(page) {
+        this.#page = page;
+        // @ts-expect-error use existing CDP client (internal Puppeteer API).
+        this.#session = this.#page._client();
+        // @ts-expect-error use internal Puppeteer API to get target ID
+        this.#targetId = this.#session.target()._targetId;
+    }
+    #resetIssueAggregator() {
+        this.#issueManager = new FakeIssuesManager();
+        if (this.#issueAggregator) {
+            this.#issueAggregator.removeEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedIssue);
+        }
+        this.#issueAggregator = new DevTools.IssueAggregator(this.#issueManager);
+        this.#issueAggregator.addEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedIssue);
+    }
+    subscribe() {
+        this.#resetIssueAggregator();
+        this.#page.on('framenavigated', this.#onFrameNavigated);
+        this.#page.on('issue', this.#onIssueAdded);
+        this.#session.on('Runtime.exceptionThrown', this.#onExceptionThrown);
+        this.#attachFrameNavigatedWithinDocumentListener();
+    }
+    unsubscribe() {
+        this.#seenKeys.clear();
+        this.#seenIssues.clear();
+        this.#detachFrameNavigatedWithinDocumentListener();
+        this.#page.off('framenavigated', this.#onFrameNavigated);
+        this.#page.off('issue', this.#onIssueAdded);
+        this.#session.off('Runtime.exceptionThrown', this.#onExceptionThrown);
+        if (this.#issueAggregator) {
+            this.#issueAggregator.removeEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedIssue);
+        }
+    }
+    #onAggregatedIssue = (event) => {
+        if (this.#seenIssues.has(event.data)) {
+            return;
+        }
+        this.#seenIssues.add(event.data);
+        this.#page.emit('devtoolsAggregatedIssue', event.data);
+    };
+    #onExceptionThrown = (event) => {
+        this.#page.emit('uncaughtError', new UncaughtError(event.exceptionDetails, this.#targetId));
+    };
+    // On navigation, we reset issue aggregation.
+    #onFrameNavigated = (frame) => {
+        // Only split the storage on main frame navigation
+        if (frame !== frame.page().mainFrame()) {
+            return;
+        }
+        // Re-attach the listener to the current main frame: a cross-document
+        // navigation may have replaced the frame object, so the reference
+        // captured at construction time would be stale.
+        this.#attachFrameNavigatedWithinDocumentListener();
+        if (this.#pendingSameDocumentNavigation) {
+            this.#pendingSameDocumentNavigation = false;
+            return;
+        }
+        this.#seenKeys.clear();
+        this.#seenIssues.clear();
+        this.#resetIssueAggregator();
+    };
+    // Puppeteer emits this right before the page-level navigation event for
+    // same-document (SPA) navigations, which lets `framenavigated` skip the
+    // issue aggregation reset for those navigations.
+    #onFrameNavigatedWithinDocument = () => {
+        this.#pendingSameDocumentNavigation = true;
+    };
+    #attachFrameNavigatedWithinDocumentListener() {
+        this.#detachFrameNavigatedWithinDocumentListener();
+        this.#frameNavigatedWithinDocumentTarget = this.#page.mainFrame();
+        this.#frameNavigatedWithinDocumentTarget.on(FrameEvent.FrameNavigatedWithinDocument, this.#onFrameNavigatedWithinDocument);
+    }
+    #detachFrameNavigatedWithinDocumentListener() {
+        if (this.#frameNavigatedWithinDocumentTarget) {
+            this.#frameNavigatedWithinDocumentTarget.off(FrameEvent.FrameNavigatedWithinDocument, this.#onFrameNavigatedWithinDocument);
+            this.#frameNavigatedWithinDocumentTarget = undefined;
+        }
+    }
+    #onIssueAdded = (inspectorIssue) => {
+        try {
+            // @ts-expect-error The types are missmatched but they
+            // are coming from CDP
+            if (!DevTools.isIssueCodeSupported(inspectorIssue.code)) {
+                return;
+            }
+            const issue = DevTools.createIssuesFromProtocolIssue(null, 
+            // @ts-expect-error Protocol types diverge.
+            inspectorIssue)[0];
+            if (!issue) {
+                logger?.('No issue mapping for for the issue: ', inspectorIssue.code);
+                return;
+            }
+            const primaryKey = issue.primaryKey();
+            if (this.#seenKeys.has(primaryKey)) {
+                return;
+            }
+            this.#seenKeys.add(primaryKey);
+            this.#issueManager.dispatchEventToListeners("IssueAdded" /* DevTools.IssuesManagerEvents.ISSUE_ADDED */, {
+                issue,
+                // @ts-expect-error We don't care that issues model is null
+                issuesModel: null,
+            });
+        }
+        catch (error) {
+            logger?.('Error creating a new issue', error);
+        }
+    };
+}
+export class NetworkCollector extends PageCollector {
+    static MAX_REQUESTS_PER_NAVIGATION = 1_000;
+    constructor(page, maxRequestsPerNavigation = NetworkCollector.MAX_REQUESTS_PER_NAVIGATION, listeners = collect => {
+        return {
+            request: req => {
+                collect(req);
+            },
+        };
+    }) {
+        super(page, listeners, maxRequestsPerNavigation);
+    }
+    splitAfterNavigation() {
+        const requests = this.storage[0];
+        const lastRequestIdx = requests.findLastIndex(request => {
+            return request.frame() === this.pptrPage.mainFrame()
+                ? request.isNavigationRequest()
+                : false;
+        });
+        // Keep all requests since the last navigation request including that
+        // navigation request itself.
+        // Keep the reference
+        if (lastRequestIdx !== -1) {
+            const fromCurrentNavigation = requests.splice(lastRequestIdx);
+            this.storage.unshift(fromCurrentNavigation);
+        }
+        else {
+            this.storage.unshift([]);
+        }
+        this.storage.splice(this.maxNavigationSaved);
+    }
+}
+//# sourceMappingURL=PageCollector.js.map