@vibebrowser/chrome-devtools-mcp 0.26.0

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

@@ -0,0 +1,350 @@
+/**
+ * @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 locally from the user data directory identified by the channel param (default channel is stable). Requires the remote 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: ['canary', 'dev', 'beta', 'stable'],
+        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.`,
+    },
+    experimentalPageIdRouting: {
+        type: 'boolean',
+        describe: 'Whether to expose pageId on page-scoped tools and route requests by page ID (useful for concurrent agent sessions).',
+    },
+    experimentalDevtools: {
+        type: 'boolean',
+        describe: 'Whether to enable automation over DevTools targets',
+    },
+    experimentalVision: {
+        type: 'boolean',
+        describe: 'Whether to enable coordinate-based tools such as click_at(x,y). Usually requires a computer-use model able to produce accurate coordinates by looking at screenshots.',
+    },
+    experimentalMemory: {
+        type: 'boolean',
+        describe: 'Whether to enable experimental memory tools.',
+    },
+    experimentalStructuredContent: {
+        type: 'boolean',
+        describe: 'Whether to output structured formatted content.',
+    },
+    experimentalIncludeAllPages: {
+        type: 'boolean',
+        describe: 'Whether to include all kinds of pages such as webviews or background pages as pages.',
+    },
+    experimentalNavigationAllowlist: {
+        type: 'boolean',
+        describe: 'Whether to enable navigation allowlist tool parameter.',
+        hidden: true,
+    },
+    experimentalInteropTools: {
+        type: 'boolean',
+        describe: 'Whether to enable interoperability tools',
+        hidden: true,
+    },
+    experimentalScreencast: {
+        type: 'boolean',
+        describe: 'Exposes experimental screencast tools (requires ffmpeg). Install ffmpeg https://www.ffmpeg.org/download.html and ensure it is available in the MCP server PATH.',
+    },
+    experimentalFfmpegPath: {
+        type: 'string',
+        describe: 'Path to ffmpeg executable for screencast recording.',
+        implies: 'experimentalScreencast',
+    },
+    categoryExperimentalWebmcp: {
+        type: 'boolean',
+        describe: 'Set to true to enable debugging WebMCP tools. Requires Chrome 149+ with the following flags: `--enable-features=WebMCPTesting,DevToolsWebMCPSupport`',
+    },
+    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',
+        hidden: false,
+        default: false,
+        describe: 'Set to true to include tools related to extensions. Note: This feature is currently only supported with a pipe connection. autoConnect, browserUrl, and wsEndpoint are not supported with this feature until 149 will be released.',
+    },
+    categoryExperimentalThirdParty: {
+        type: 'boolean',
+        default: false,
+        describe: 'Set to true to enable third-party developer tools exposed by the inspected page itself',
+    },
+    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).',
+    },
+    slim: {
+        type: 'boolean',
+        describe: 'Exposes a "slim" set of 3 tools covering navigation, script execution and screenshots only. Useful for basic browser tasks.',
+    },
+    viaCli: {
+        type: 'boolean',
+        describe: 'Set by Chrome DevTools CLI if the MCP server is started via the CLI client (this arg exists for usage stats)',
+        hidden: true,
+    },
+    redactNetworkHeaders: {
+        type: 'boolean',
+        describe: 'If true, redacts some of the network headers considered senstive before returning to the client.',
+        default: false,
+    },
+    port: {
+        type: 'number',
+        describe: 'If specified, starts a Streamable HTTP transport on the given port instead of stdio. Allows multiple agents to connect to the same MCP server instance over HTTP.',
+        alias: 'p',
+    },
+};
+export function parseArguments(version, argv = process.argv, env = process.env) {
+    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';
+        }
+        if (env['CI'] || env['CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS']) {
+            console.error("turning off usage statistics. process.env['CI'] || process.env['CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS'] is set.");
+            args.usageStatistics = false;
+        }
+        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.',
+        ],
+        [
+            '$0 --slim',
+            'Only 3 tools: navigation, JavaScript execution and screenshot',
+        ],
+    ]);
+    return yargsInstance
+        .wrap(Math.min(120, yargsInstance.terminalWidth()))
+        .help()
+        .version(version)
+        .parseSync();
+}
+//# sourceMappingURL=chrome-devtools-mcp-cli-options.js.map

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

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import '../polyfill.js';
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import process from 'node:process';
+import { createMcpServer, logDisclaimers } from '../index.js';
+import { logger, saveLogsToFile } from '../logger.js';
+import { ClearcutLogger } from '../telemetry/ClearcutLogger.js';
+import { computeFlagUsage } from '../telemetry/flagUtils.js';
+import { StdioServerTransport, StreamableHTTPServerTransport, } from '../third_party/index.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { checkForUpdates } from '../utils/check-for-updates.js';
+import { VERSION } from '../version.js';
+import { cliOptions, parseArguments } from './chrome-devtools-mcp-cli-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 { server } = await createMcpServer(args, {
+    logFile,
+});
+if (args.port) {
+    const sessions = new Map();
+    const httpServer = createServer(async (req, res) => {
+        const url = new URL(req.url || '/', `http://localhost:${args.port}`);
+        if (url.pathname === '/mcp') {
+            const sessionId = req.headers['mcp-session-id'];
+            if (sessionId && sessions.has(sessionId)) {
+                const transport = sessions.get(sessionId);
+                await transport.handleRequest(req, res);
+                return;
+            }
+            // Parse body for initialization detection
+            const body = await new Promise(resolve => {
+                let data = '';
+                req.on('data', chunk => (data += chunk));
+                req.on('end', () => resolve(data));
+            });
+            const jsonBody = JSON.parse(body);
+            if (isInitializeRequest(jsonBody) ||
+                (Array.isArray(jsonBody) && jsonBody.some(isInitializeRequest))) {
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                });
+                transport.onclose = () => {
+                    const id = [...sessions.entries()].find(([, t]) => t === transport)?.[0];
+                    if (id)
+                        sessions.delete(id);
+                };
+                await server.connect(transport);
+                await transport.handleRequest(req, res, jsonBody);
+                // Extract session ID from response headers
+                const respSessionId = res.getHeader('mcp-session-id');
+                if (respSessionId) {
+                    sessions.set(respSessionId, transport);
+                }
+            }
+            else if (sessionId) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Session not found' }));
+            }
+            else {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Missing mcp-session-id header' }));
+            }
+        }
+        else {
+            res.writeHead(404);
+            res.end('Not found. Use /mcp endpoint.');
+        }
+    });
+    httpServer.listen(args.port, () => {
+        logger(`Chrome DevTools MCP Server listening on http://localhost:${args.port}/mcp`);
+        console.error(`Chrome DevTools MCP Server listening on http://localhost:${args.port}/mcp`);
+    });
+}
+else {
+    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, cliOptions));
+//# sourceMappingURL=chrome-devtools-mcp-main.js.map

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

@@ -0,0 +1,31 @@
+#!/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);
+}
+const subcommand = process.argv[2];
+if (subcommand === 'install' || subcommand === 'uninstall' || subcommand === 'status') {
+    // Pass remaining args after the subcommand, then append the action
+    process.argv = [process.argv[0], process.argv[1], ...process.argv.slice(3), subcommand];
+    await import('./install-service.js');
+}
+else {
+    await import('./chrome-devtools-mcp-main.js');
+}
+//# sourceMappingURL=chrome-devtools-mcp.js.map

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

@@ -0,0 +1,189 @@
+#!/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, } from '../daemon/client.js';
+import { isDaemonRunning, serializeArgs } 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 { commands } from './chrome-devtools-cli-options.js';
+import { cliOptions, parseArguments } from './chrome-devtools-mcp-cli-options.js';
+await checkForUpdates('Run `npm install -g chrome-devtools-mcp@latest` and `chrome-devtools start` to update and restart the daemon.');
+async function start(args, sessionId) {
+    const combinedArgs = [...args, ...defaultArgs];
+    await startDaemon(combinedArgs, sessionId);
+    logDisclaimers(parseArguments(VERSION, combinedArgs));
+}
+const defaultArgs = ['--viaCli', '--experimentalStructuredContent'];
+const startCliOptions = {
+    ...cliOptions,
+};
+// Missing CLI serialization.
+delete startCliOptions.viewport;
+// Change the defaults for the CLI.
+delete startCliOptions.experimentalStructuredContent;
+delete startCliOptions.experimentalInteropTools;
+delete startCliOptions.experimentalPageIdRouting;
+if (!('default' in cliOptions.headless)) {
+    throw new Error('headless cli option unexpectedly does not have a default');
+}
+if ('default' in cliOptions.isolated) {
+    throw new Error('isolated cli option unexpectedly has a default');
+}
+startCliOptions.headless.default = true;
+startCliOptions.isolated.description =
+    'If specified, creates a temporary user-data-dir that is automatically cleaned up after the browser is closed. Defaults to true unless userDataDir is provided.';
+startCliOptions.categoryExtensions.default = true;
+const y = yargs(hideBin(process.argv))
+    .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: '',
+    hidden: true,
+})
+    .demandCommand()
+    .version(VERSION)
+    .strict()
+    .help(true)
+    .wrap(120);
+y.command('start', 'Start or restart chrome-devtools-mcp', y => y
+    .options(startCliOptions)
+    .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.isolated = true;
+    }
+    if (argv.headless === undefined) {
+        argv.headless = true;
+    }
+    const args = serializeArgs(cliOptions, 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)}`);
+        }
+        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 requiredArgNames = Object.keys(args).filter(name => args[name].required);
+    const optionalArgNames = Object.keys(args).filter(name => !args[name].required);
+    let commandStr = commandName;
+    for (const arg of requiredArgNames) {
+        commandStr += ` <${arg}>`;
+    }
+    for (const arg of optionalArgNames) {
+        commandStr += ` [--${arg}]`;
+    }
+    y.command(commandStr, commandDef.description, y => {
+        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 {
+            if (!isDaemonRunning(sessionId)) {
+                await start([], 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);
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error('Failed to execute command:', error);
+            process.exit(1);
+        }
+    });
+}
+await y.parse();
+//# sourceMappingURL=chrome-devtools.js.map