chrome-devtools-mcp 0.17.1 → 0.17.2

package/build/src/cli.js

@@ -1,295 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { yargs, hideBin } from './third_party/index.js';
-export const cliOptions = {
-    autoConnect: {
-        type: 'boolean',
-        description: 'If specified, automatically connects to a browser (Chrome 144+) running in the user data directory identified by the channel param. Requires the remoted debugging server to be started in the Chrome instance via chrome://inspect/#remote-debugging.',
-        conflicts: ['isolated', 'executablePath'],
-        default: false,
-        coerce: (value) => {
-            if (!value) {
-                return;
-            }
-            return value;
-        },
-    },
-    browserUrl: {
-        type: 'string',
-        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) => {
-            if (!url) {
-                return;
-            }
-            try {
-                new URL(url);
-            }
-            catch {
-                throw new Error(`Provided browserUrl ${url} is not valid URL.`);
-            }
-            return url;
-        },
-    },
-    wsEndpoint: {
-        type: 'string',
-        description: 'WebSocket endpoint to connect to a running Chrome instance (e.g., ws://127.0.0.1:9222/devtools/browser/<id>). Alternative to --browserUrl.',
-        alias: 'w',
-        conflicts: 'browserUrl',
-        coerce: (url) => {
-            if (!url) {
-                return;
-            }
-            try {
-                const parsed = new URL(url);
-                if (parsed.protocol !== 'ws:' && parsed.protocol !== 'wss:') {
-                    throw new Error(`Provided wsEndpoint ${url} must use ws:// or wss:// protocol.`);
-                }
-                return url;
-            }
-            catch (error) {
-                if (error.message.includes('ws://')) {
-                    throw error;
-                }
-                throw new Error(`Provided wsEndpoint ${url} is not valid URL.`);
-            }
-        },
-    },
-    wsHeaders: {
-        type: 'string',
-        description: 'Custom headers for WebSocket connection in JSON format (e.g., \'{"Authorization":"Bearer token"}\'). Only works with --wsEndpoint.',
-        implies: 'wsEndpoint',
-        coerce: (val) => {
-            if (!val) {
-                return;
-            }
-            try {
-                const parsed = JSON.parse(val);
-                if (typeof parsed !== 'object' || Array.isArray(parsed)) {
-                    throw new Error('Headers must be a JSON object');
-                }
-                return parsed;
-            }
-            catch (error) {
-                throw new Error(`Invalid JSON for wsHeaders: ${error.message}`);
-            }
-        },
-    },
-    headless: {
-        type: 'boolean',
-        description: 'Whether to run in headless (no UI) mode.',
-        default: false,
-    },
-    executablePath: {
-        type: 'string',
-        description: 'Path to custom Chrome executable.',
-        conflicts: ['browserUrl', 'wsEndpoint'],
-        alias: 'e',
-    },
-    isolated: {
-        type: 'boolean',
-        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',
-        description: 'Specify a different Chrome channel that should be used. The default is the stable channel version.',
-        choices: ['stable', 'canary', 'beta', 'dev'],
-        conflicts: ['browserUrl', 'wsEndpoint', 'executablePath'],
-    },
-    logFile: {
-        type: 'string',
-        describe: 'Path to a file to write debug logs to. Set the env variable `DEBUG` to `*` to enable verbose logs. Useful for submitting bug reports.',
-    },
-    viewport: {
-        type: 'string',
-        describe: 'Initial viewport size for the Chrome instances started by the server. For example, `1280x720`. In headless mode, max size is 3840x2160px.',
-        coerce: (arg) => {
-            if (arg === undefined) {
-                return;
-            }
-            const [width, height] = arg.split('x').map(Number);
-            if (!width || !height || Number.isNaN(width) || Number.isNaN(height)) {
-                throw new Error('Invalid viewport. Expected format is `1280x720`.');
-            }
-            return {
-                width,
-                height,
-            };
-        },
-    },
-    proxyServer: {
-        type: 'string',
-        description: `Proxy server configuration for Chrome passed as --proxy-server when launching the browser. See https://www.chromium.org/developers/design-documents/network-settings/ for details.`,
-    },
-    acceptInsecureCerts: {
-        type: 'boolean',
-        description: `If enabled, ignores errors relative to self-signed and expired certificates. Use with caution.`,
-    },
-    experimentalDevtools: {
-        type: 'boolean',
-        describe: 'Whether to enable automation over DevTools targets',
-        hidden: true,
-    },
-    experimentalVision: {
-        type: 'boolean',
-        describe: 'Whether to enable vision tools',
-        hidden: true,
-    },
-    experimentalStructuredContent: {
-        type: 'boolean',
-        describe: 'Whether to output structured formatted content.',
-        hidden: true,
-    },
-    experimentalIncludeAllPages: {
-        type: 'boolean',
-        describe: 'Whether to include all kinds of pages such as webviews or background pages as pages.',
-        hidden: true,
-    },
-    experimentalInteropTools: {
-        type: 'boolean',
-        describe: 'Whether to enable interoperability tools',
-        hidden: true,
-    },
-    chromeArg: {
-        type: 'array',
-        describe: 'Additional arguments for Chrome. Only applies when Chrome is launched by chrome-devtools-mcp.',
-    },
-    ignoreDefaultChromeArg: {
-        type: 'array',
-        describe: 'Explicitly disable default arguments for Chrome. Only applies when Chrome is launched by chrome-devtools-mcp.',
-    },
-    categoryEmulation: {
-        type: 'boolean',
-        default: true,
-        describe: 'Set to false to exclude tools related to emulation.',
-    },
-    categoryPerformance: {
-        type: 'boolean',
-        default: true,
-        describe: 'Set to false to exclude tools related to performance.',
-    },
-    categoryNetwork: {
-        type: 'boolean',
-        default: true,
-        describe: 'Set to false to exclude tools related to network.',
-    },
-    categoryExtensions: {
-        type: 'boolean',
-        default: false,
-        hidden: true,
-        describe: 'Set to false to exclude tools related to extensions.',
-    },
-    performanceCrux: {
-        type: 'boolean',
-        default: true,
-        describe: 'Set to false to disable sending URLs from performance traces to CrUX API to get field performance data.',
-    },
-    usageStatistics: {
-        type: 'boolean',
-        default: true,
-        describe: 'Set to false to opt-out of usage statistics collection. Google collects usage data to improve the tool, handled under the Google Privacy Policy (https://policies.google.com/privacy). This is independent from Chrome browser metrics. Disabled if CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS or CI env variables are set.',
-    },
-    clearcutEndpoint: {
-        type: 'string',
-        hidden: true,
-        describe: 'Endpoint for Clearcut telemetry.',
-    },
-    clearcutForceFlushIntervalMs: {
-        type: 'number',
-        hidden: true,
-        describe: 'Force flush interval in milliseconds (for testing).',
-    },
-    clearcutIncludePidHeader: {
-        type: 'boolean',
-        hidden: true,
-        describe: 'Include watchdog PID in Clearcut request headers (for testing).',
-    },
-};
-export function parseArguments(version, argv = process.argv) {
-    const yargsInstance = yargs(hideBin(argv))
-        .scriptName('npx chrome-devtools-mcp@latest')
-        .options(cliOptions)
-        .check(args => {
-        // We can't set default in the options else
-        // Yargs will complain
-        if (!args.channel &&
-            !args.browserUrl &&
-            !args.wsEndpoint &&
-            !args.executablePath) {
-            args.channel = 'stable';
-        }
-        return true;
-    })
-        .example([
-        [
-            '$0 --browserUrl http://127.0.0.1:9222',
-            'Connect to an existing browser instance via HTTP',
-        ],
-        [
-            '$0 --wsEndpoint ws://127.0.0.1:9222/devtools/browser/abc123',
-            'Connect to an existing browser instance via WebSocket',
-        ],
-        [
-            `$0 --wsEndpoint ws://127.0.0.1:9222/devtools/browser/abc123 --wsHeaders '{"Authorization":"Bearer token"}'`,
-            'Connect via WebSocket with custom headers',
-        ],
-        ['$0 --channel beta', 'Use Chrome Beta installed on this system'],
-        ['$0 --channel canary', 'Use Chrome Canary installed on this system'],
-        ['$0 --channel dev', 'Use Chrome Dev installed on this system'],
-        ['$0 --channel stable', 'Use stable Chrome installed on this system'],
-        ['$0 --logFile /tmp/log.txt', 'Save logs to a file'],
-        ['$0 --help', 'Print CLI options'],
-        [
-            '$0 --viewport 1280x720',
-            'Launch Chrome with the initial viewport size of 1280x720px',
-        ],
-        [
-            `$0 --chrome-arg='--no-sandbox' --chrome-arg='--disable-setuid-sandbox'`,
-            'Launch Chrome without sandboxes. Use with caution.',
-        ],
-        [
-            `$0 --ignore-default-chrome-arg='--disable-extensions'`,
-            'Disable the default arguments provided by Puppeteer. Use with caution.',
-        ],
-        ['$0 --no-category-emulation', 'Disable tools in the emulation category'],
-        [
-            '$0 --no-category-performance',
-            '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 144+) running instead of launching a new instance',
-        ],
-        [
-            '$0 --auto-connect --channel=canary',
-            'Connect to a canary Chrome instance (Chrome 144+) running instead of launching a new instance',
-        ],
-        [
-            '$0 --no-usage-statistics',
-            'Do not send usage statistics https://github.com/ChromeDevTools/chrome-devtools-mcp#usage-statistics.',
-        ],
-        [
-            '$0 --no-performance-crux',
-            'Disable CrUX (field data) integration in performance tools.',
-        ],
-    ]);
-    return yargsInstance
-        .wrap(Math.min(120, yargsInstance.terminalWidth()))
-        .help()
-        .version(version)
-        .parseSync();
-}

package/build/src/formatters/ConsoleFormatter.js

@@ -1,240 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-var _a;
-import { createStackTraceForConsoleMessage, SymbolizedError, } from '../DevtoolsUtils.js';
-import { UncaughtError } from '../PageCollector.js';
-import * as DevTools from '../third_party/index.js';
-export class ConsoleFormatter {
-    static #STACK_TRACE_MAX_LINES = 50;
-    #id;
-    #type;
-    #text;
-    #argCount;
-    #resolvedArgs;
-    #stack;
-    #cause;
-    #isIgnored;
-    constructor(params) {
-        this.#id = params.id;
-        this.#type = params.type;
-        this.#text = params.text;
-        this.#argCount = params.argCount ?? 0;
-        this.#resolvedArgs = params.resolvedArgs ?? [];
-        this.#stack = params.stack;
-        this.#cause = params.cause;
-        this.#isIgnored = params.isIgnored;
-    }
-    static async from(msg, options) {
-        const ignoreListManager = options?.devTools?.universe.context.get(DevTools.DevTools.IgnoreListManager);
-        const isIgnored = options.isIgnoredForTesting ||
-            (frame => {
-                if (!ignoreListManager) {
-                    return false;
-                }
-                if (frame.uiSourceCode) {
-                    return ignoreListManager.isUserOrSourceMapIgnoreListedUISourceCode(frame.uiSourceCode);
-                }
-                if (frame.url) {
-                    return ignoreListManager.isUserIgnoreListedURL(frame.url);
-                }
-                return false;
-            });
-        if (msg instanceof UncaughtError) {
-            const error = await SymbolizedError.fromDetails({
-                devTools: options?.devTools,
-                details: msg.details,
-                targetId: msg.targetId,
-                includeStackAndCause: options?.fetchDetailedData,
-                resolvedStackTraceForTesting: options?.resolvedStackTraceForTesting,
-                resolvedCauseForTesting: options?.resolvedCauseForTesting,
-            });
-            return new _a({
-                id: options.id,
-                type: 'error',
-                text: error.message,
-                stack: error.stackTrace,
-                cause: error.cause,
-                isIgnored,
-            });
-        }
-        let resolvedArgs = [];
-        if (options.resolvedArgsForTesting) {
-            resolvedArgs = options.resolvedArgsForTesting;
-        }
-        else if (options.fetchDetailedData) {
-            resolvedArgs = await Promise.all(msg.args().map(async (arg, i) => {
-                try {
-                    const remoteObject = arg.remoteObject();
-                    if (remoteObject.type === 'object' &&
-                        remoteObject.subtype === 'error') {
-                        return await SymbolizedError.fromError({
-                            devTools: options.devTools,
-                            error: remoteObject,
-                            // @ts-expect-error Internal ConsoleMessage API
-                            targetId: msg._targetId(),
-                        });
-                    }
-                    return await arg.jsonValue();
-                }
-                catch {
-                    return `<error: Argument ${i} is no longer available>`;
-                }
-            }));
-        }
-        let stack;
-        if (options.resolvedStackTraceForTesting) {
-            stack = options.resolvedStackTraceForTesting;
-        }
-        else if (options.fetchDetailedData && options.devTools) {
-            try {
-                stack = await createStackTraceForConsoleMessage(options.devTools, msg);
-            }
-            catch {
-                // ignore
-            }
-        }
-        return new _a({
-            id: options.id,
-            type: msg.type(),
-            text: msg.text(),
-            argCount: resolvedArgs.length || msg.args().length,
-            resolvedArgs,
-            stack,
-            isIgnored,
-        });
-    }
-    // The short format for a console message.
-    toString() {
-        return `msgid=${this.#id} [${this.#type}] ${this.#text} (${this.#argCount} args)`;
-    }
-    // The verbose format for a console message, including all details.
-    toStringDetailed() {
-        const result = [
-            `ID: ${this.#id}`,
-            `Message: ${this.#type}> ${this.#text}`,
-            this.#formatArgs(),
-            this.#formatStackTrace(this.#stack, this.#cause, {
-                includeHeading: true,
-            }),
-        ].filter(line => !!line);
-        return result.join('\n');
-    }
-    #getArgs() {
-        if (this.#resolvedArgs.length > 0) {
-            const args = [...this.#resolvedArgs];
-            // If there is no text, the first argument serves as text (see formatMessage).
-            if (!this.#text) {
-                args.shift();
-            }
-            return args;
-        }
-        return [];
-    }
-    #formatArg(arg) {
-        if (arg instanceof SymbolizedError) {
-            return [
-                arg.message,
-                this.#formatStackTrace(arg.stackTrace, arg.cause, {
-                    includeHeading: false,
-                }),
-            ]
-                .filter(line => !!line)
-                .join('\n');
-        }
-        return typeof arg === 'object' ? JSON.stringify(arg) : String(arg);
-    }
-    #formatArgs() {
-        const args = this.#getArgs();
-        if (!args.length) {
-            return '';
-        }
-        const result = ['### Arguments'];
-        for (const [key, arg] of args.entries()) {
-            result.push(`Arg #${key}: ${this.#formatArg(arg)}`);
-        }
-        return result.join('\n');
-    }
-    #formatStackTrace(stackTrace, cause, opts) {
-        if (!stackTrace) {
-            return '';
-        }
-        const lines = this.#formatStackTraceInner(stackTrace, cause);
-        const includedLines = lines.slice(0, _a.#STACK_TRACE_MAX_LINES);
-        const reminderCount = lines.length - includedLines.length;
-        return [
-            opts.includeHeading ? '### Stack trace' : '',
-            ...includedLines,
-            reminderCount > 0 ? `... and ${reminderCount} more frames` : '',
-            'Note: line and column numbers use 1-based indexing',
-        ]
-            .filter(line => !!line)
-            .join('\n');
-    }
-    #formatStackTraceInner(stackTrace, cause) {
-        if (!stackTrace) {
-            return [];
-        }
-        return [
-            ...this.#formatFragment(stackTrace.syncFragment),
-            ...stackTrace.asyncFragments
-                .map(this.#formatAsyncFragment.bind(this))
-                .flat(),
-            ...this.#formatCause(cause),
-        ];
-    }
-    #formatFragment(fragment) {
-        const frames = fragment.frames.filter(frame => !this.#isIgnored(frame));
-        return frames.map(this.#formatFrame.bind(this));
-    }
-    #formatAsyncFragment(fragment) {
-        const formattedFrames = this.#formatFragment(fragment);
-        if (formattedFrames.length === 0) {
-            return [];
-        }
-        const separatorLineLength = 40;
-        const prefix = `--- ${fragment.description || 'async'} `;
-        const separator = prefix + '-'.repeat(separatorLineLength - prefix.length);
-        return [separator, ...formattedFrames];
-    }
-    #formatFrame(frame) {
-        let result = `at ${frame.name ?? '<anonymous>'}`;
-        if (frame.uiSourceCode) {
-            const location = frame.uiSourceCode.uiLocation(frame.line, frame.column);
-            result += ` (${location.linkText(/* skipTrim */ false, /* showColumnNumber */ true)})`;
-        }
-        else if (frame.url) {
-            result += ` (${frame.url}:${frame.line}:${frame.column})`;
-        }
-        return result;
-    }
-    #formatCause(cause) {
-        if (!cause) {
-            return [];
-        }
-        return [
-            `Caused by: ${cause.message}`,
-            ...this.#formatStackTraceInner(cause.stackTrace, cause.cause),
-        ];
-    }
-    toJSON() {
-        return {
-            type: this.#type,
-            text: this.#text,
-            argsCount: this.#argCount,
-            id: this.#id,
-        };
-    }
-    toJSONDetailed() {
-        return {
-            id: this.#id,
-            type: this.#type,
-            text: this.#text,
-            args: this.#getArgs().map(arg => typeof arg === 'object' ? arg : String(arg)),
-            stackTrace: this.#stack,
-        };
-    }
-}
-_a = ConsoleFormatter;