@mcp-b/chrome-devtools-mcp 2.3.0 → 2.3.1-beta.20260528050333

package/build/src/browser.js

@@ -1,198 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { execSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { logger } from './logger.js';
-import { puppeteer } from './third_party/index.js';
-let browser;
-function makeTargetFilter(enableExtensions = false) {
-    const ignoredPrefixes = new Set(['chrome://', 'chrome-untrusted://']);
-    if (!enableExtensions) {
-        ignoredPrefixes.add('chrome-extension://');
-    }
-    return function targetFilter(target) {
-        if (target.url() === 'chrome://newtab/') {
-            return true;
-        }
-        // Could be the only page opened in the browser.
-        if (target.url().startsWith('chrome://inspect')) {
-            return true;
-        }
-        for (const prefix of ignoredPrefixes) {
-            if (target.url().startsWith(prefix)) {
-                return false;
-            }
-        }
-        return true;
-    };
-}
-export async function ensureBrowserConnected(options) {
-    const { channel, enableExtensions } = options;
-    if (browser?.connected) {
-        return browser;
-    }
-    const connectOptions = {
-        targetFilter: makeTargetFilter(enableExtensions),
-        defaultViewport: null,
-        handleDevToolsAsPage: true,
-    };
-    let autoConnect = false;
-    if (options.wsEndpoint) {
-        connectOptions.browserWSEndpoint = options.wsEndpoint;
-        if (options.wsHeaders) {
-            connectOptions.headers = options.wsHeaders;
-        }
-    }
-    else if (options.browserURL) {
-        connectOptions.browserURL = options.browserURL;
-    }
-    else if (channel || options.userDataDir) {
-        const userDataDir = options.userDataDir;
-        if (userDataDir) {
-            autoConnect = true;
-            // TODO: re-expose this logic via Puppeteer.
-            const portPath = path.join(userDataDir, 'DevToolsActivePort');
-            try {
-                const fileContent = await fs.promises.readFile(portPath, 'utf8');
-                const [rawPort, rawPath] = fileContent
-                    .split('\n')
-                    .map((line) => {
-                    return line.trim();
-                })
-                    .filter((line) => {
-                    return !!line;
-                });
-                if (!rawPort || !rawPath) {
-                    throw new Error(`Invalid DevToolsActivePort '${fileContent}' found`);
-                }
-                const port = parseInt(rawPort, 10);
-                if (isNaN(port) || port <= 0 || port > 65535) {
-                    throw new Error(`Invalid port '${rawPort}' found`);
-                }
-                const browserWSEndpoint = `ws://127.0.0.1:${port}${rawPath}`;
-                connectOptions.browserWSEndpoint = browserWSEndpoint;
-            }
-            catch (error) {
-                throw new Error(`Could not connect to Chrome in ${userDataDir}. Check if Chrome is running and remote debugging is enabled by going to chrome://inspect/#remote-debugging.`, {
-                    cause: error,
-                });
-            }
-        }
-        else {
-            if (!channel) {
-                throw new Error('Channel must be provided if userDataDir is missing');
-            }
-            connectOptions.channel = (channel === 'stable' ? 'chrome' : `chrome-${channel}`);
-        }
-    }
-    else {
-        throw new Error('Either browserURL, wsEndpoint, channel or userDataDir must be provided');
-    }
-    logger('Connecting Puppeteer to ', JSON.stringify(connectOptions));
-    try {
-        browser = await puppeteer.connect(connectOptions);
-    }
-    catch (err) {
-        throw new Error(`Could not connect to Chrome. ${autoConnect ? `Check if Chrome is running and remote debugging is enabled by going to chrome://inspect/#remote-debugging.` : `Check if Chrome is running.`}`, {
-            cause: err,
-        });
-    }
-    logger('Connected Puppeteer');
-    return browser;
-}
-export function detectDisplay() {
-    // Only detect display on Linux/UNIX.
-    if (os.platform() === 'win32' || os.platform() === 'darwin') {
-        return;
-    }
-    if (!process.env['DISPLAY']) {
-        try {
-            const result = execSync(`ps -u $(id -u) -o pid= | xargs -I{} cat /proc/{}/environ 2>/dev/null | tr '\\0' '\\n' | grep -m1 '^DISPLAY=' | cut -d= -f2`);
-            const display = result.toString('utf8').trim();
-            process.env['DISPLAY'] = display;
-        }
-        catch {
-            // no-op
-        }
-    }
-}
-export async function launch(options) {
-    const { channel, executablePath, headless, isolated } = options;
-    const profileDirName = channel && channel !== 'stable' ? `chrome-profile-${channel}` : 'chrome-profile';
-    let userDataDir = options.userDataDir;
-    if (!isolated && !userDataDir) {
-        userDataDir = path.join(os.homedir(), '.cache', options.viaCli ? 'chrome-devtools-mcp-cli' : 'chrome-devtools-mcp', profileDirName);
-        await fs.promises.mkdir(userDataDir, {
-            recursive: true,
-        });
-    }
-    const args = [
-        ...(options.chromeArgs ?? []),
-        '--hide-crash-restore-bubble',
-    ];
-    const ignoreDefaultArgs = options.ignoreDefaultChromeArgs ?? false;
-    if (headless) {
-        args.push('--screen-info={3840x2160}');
-    }
-    let puppeteerChannel;
-    if (options.devtools) {
-        args.push('--auto-open-devtools-for-tabs');
-    }
-    if (!executablePath) {
-        puppeteerChannel =
-            channel && channel !== 'stable' ? `chrome-${channel}` : 'chrome';
-    }
-    if (!headless) {
-        detectDisplay();
-    }
-    try {
-        const browser = await puppeteer.launch({
-            channel: puppeteerChannel,
-            targetFilter: makeTargetFilter(options.enableExtensions),
-            executablePath,
-            defaultViewport: null,
-            userDataDir,
-            pipe: true,
-            headless,
-            args,
-            ignoreDefaultArgs: ignoreDefaultArgs,
-            acceptInsecureCerts: options.acceptInsecureCerts,
-            handleDevToolsAsPage: true,
-            enableExtensions: options.enableExtensions,
-        });
-        if (options.logFile) {
-            // FIXME: we are probably subscribing too late to catch startup logs. We
-            // should expose the process earlier or expose the getRecentLogs() getter.
-            browser.process()?.stderr?.pipe(options.logFile);
-            browser.process()?.stdout?.pipe(options.logFile);
-        }
-        if (options.viewport) {
-            const [page] = await browser.pages();
-            await page?.resize({
-                contentWidth: options.viewport.width,
-                contentHeight: options.viewport.height,
-            });
-        }
-        return browser;
-    }
-    catch (error) {
-        if (userDataDir && error.message.includes('The browser is already running')) {
-            throw new Error(`The browser is already running for ${userDataDir}. Use --isolated to run multiple browser instances.`, {
-                cause: error,
-            });
-        }
-        throw error;
-    }
-}
-export async function ensureBrowserLaunched(options) {
-    if (browser?.connected) {
-        return browser;
-    }
-    browser = await launch(options);
-    return browser;
-}

package/build/src/daemon/client.js

@@ -1,152 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import net from 'node:net';
-import { logger } from '../logger.js';
-import { PipeTransport } from '../third_party/index.js';
-import { saveTemporaryFile } from '../utils/files.js';
-import { DAEMON_SCRIPT_PATH, getSocketPath, getPidFilePath, isDaemonRunning, } from './utils.js';
-const FILE_TIMEOUT = 10_000;
-/**
- * Waits for a file to be created and populated (removed = false) or removed (removed = true).
- */
-function waitForFile(filePath, removed = false) {
-    return new Promise((resolve, reject) => {
-        const check = () => {
-            const exists = fs.existsSync(filePath);
-            if (removed) {
-                return !exists;
-            }
-            if (!exists) {
-                return false;
-            }
-            try {
-                return fs.statSync(filePath).size > 0;
-            }
-            catch {
-                return false;
-            }
-        };
-        if (check()) {
-            resolve();
-            return;
-        }
-        const timer = setTimeout(() => {
-            fs.unwatchFile(filePath);
-            reject(new Error(`Timeout: file ${filePath} ${removed ? 'not removed' : 'not found'} within ${FILE_TIMEOUT}ms`));
-        }, FILE_TIMEOUT);
-        fs.watchFile(filePath, { interval: 500 }, () => {
-            if (check()) {
-                clearTimeout(timer);
-                fs.unwatchFile(filePath);
-                resolve();
-            }
-        });
-    });
-}
-export async function startDaemon(mcpArgs = []) {
-    if (isDaemonRunning()) {
-        logger('Daemon is already running');
-        return;
-    }
-    const pidFilePath = getPidFilePath();
-    if (fs.existsSync(pidFilePath)) {
-        fs.unlinkSync(pidFilePath);
-    }
-    logger('Starting daemon...', ...mcpArgs);
-    const child = spawn(process.execPath, [DAEMON_SCRIPT_PATH, ...mcpArgs], {
-        detached: true,
-        stdio: 'ignore',
-        env: process.env,
-        cwd: process.cwd(),
-        windowsHide: true,
-    });
-    child.unref();
-    await waitForFile(pidFilePath);
-}
-const SEND_COMMAND_TIMEOUT = 60_000; // ms
-/**
- * `sendCommand` opens a socket connection sends a single command and disconnects.
- */
-export async function sendCommand(command) {
-    const socketPath = getSocketPath();
-    const socket = net.createConnection({
-        path: socketPath,
-    });
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            socket.destroy();
-            reject(new Error('Timeout waiting for daemon response'));
-        }, SEND_COMMAND_TIMEOUT);
-        const transport = new PipeTransport(socket, socket);
-        transport.onmessage = async (message) => {
-            clearTimeout(timer);
-            logger('onmessage', message);
-            resolve(JSON.parse(message));
-        };
-        socket.on('error', error => {
-            clearTimeout(timer);
-            logger('Socket error:', error);
-            reject(error);
-        });
-        socket.on('close', () => {
-            clearTimeout(timer);
-            logger('Socket closed:');
-            reject(new Error('Socket closed'));
-        });
-        logger('Sending message', command);
-        transport.send(JSON.stringify(command));
-    });
-}
-export async function stopDaemon() {
-    if (!isDaemonRunning()) {
-        logger('Daemon is not running');
-        return;
-    }
-    const pidFilePath = getPidFilePath();
-    await sendCommand({ method: 'stop' });
-    await waitForFile(pidFilePath, /*removed=*/ true);
-}
-export async function handleResponse(response, format) {
-    if (response.isError) {
-        return JSON.stringify(response.content);
-    }
-    if (format === 'json') {
-        if (response.structuredContent) {
-            return JSON.stringify(response.structuredContent);
-        }
-        // Fall-through to text for backward compatibility.
-    }
-    const chunks = [];
-    for (const content of response.content) {
-        if (content.type === 'text') {
-            chunks.push(content.text);
-        }
-        else if (content.type === 'image') {
-            const imageData = content.data;
-            const mimeType = content.mimeType;
-            let extension = '.png';
-            switch (mimeType) {
-                case 'image/jpg':
-                case 'image/jpeg':
-                    extension = '.jpeg';
-                    break;
-                case 'webp':
-                    extension = '.webp';
-                    break;
-            }
-            const data = Buffer.from(imageData, 'base64');
-            const name = crypto.randomUUID();
-            const { filepath } = await saveTemporaryFile(data, `${name}${extension}`);
-            chunks.push(`Saved to ${filepath}.`);
-        }
-        else {
-            throw new Error('Not supported response content type');
-        }
-    }
-    return format === 'md' ? chunks.join(' ') : JSON.stringify(chunks);
-}

package/build/src/daemon/daemon.js

@@ -1,206 +0,0 @@
-#!/usr/bin/env node
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import fs from 'node:fs';
-import { createServer } from 'node:net';
-import path from 'node:path';
-import process from 'node:process';
-import { logger } from '../logger.js';
-import { Client, PipeTransport, StdioClientTransport, } from '../third_party/index.js';
-import { VERSION } from '../version.js';
-import { getDaemonPid, getPidFilePath, getSocketPath, INDEX_SCRIPT_PATH, IS_WINDOWS, isDaemonRunning, } from './utils.js';
-const pid = getDaemonPid();
-if (isDaemonRunning(pid)) {
-    logger('Another daemon process is running.');
-    process.exit(1);
-}
-const pidFilePath = getPidFilePath();
-fs.mkdirSync(path.dirname(pidFilePath), {
-    recursive: true,
-});
-fs.writeFileSync(pidFilePath, process.pid.toString());
-logger(`Writing ${process.pid.toString()} to ${pidFilePath}`);
-const socketPath = getSocketPath();
-const startDate = new Date();
-const mcpServerArgs = process.argv.slice(2);
-let mcpClient = null;
-let mcpTransport = null;
-let server = null;
-async function setupMCPClient() {
-    console.log('Setting up MCP client connection...');
-    // Create stdio transport for chrome-devtools-mcp
-    // Workaround for https://github.com/modelcontextprotocol/typescript-sdk/blob/v1.x/src/client/stdio.ts#L128
-    // which causes the console window to show on Windows.
-    // @ts-expect-error no types for type.
-    process.type = 'mcp-client';
-    mcpTransport = new StdioClientTransport({
-        command: process.execPath,
-        args: [INDEX_SCRIPT_PATH, ...mcpServerArgs],
-        env: process.env,
-    });
-    mcpClient = new Client({
-        name: 'chrome-devtools-cli-daemon',
-        version: VERSION,
-    }, {
-        capabilities: {},
-    });
-    await mcpClient.connect(mcpTransport);
-    console.log('MCP client connected');
-}
-async function handleRequest(msg) {
-    try {
-        if (msg.method === 'invoke_tool') {
-            if (!mcpClient) {
-                throw new Error('MCP client not initialized');
-            }
-            const { tool, args } = msg;
-            const result = (await mcpClient.callTool({
-                name: tool,
-                arguments: args || {},
-            }));
-            return {
-                success: true,
-                result: JSON.stringify(result),
-            };
-        }
-        else if (msg.method === 'stop') {
-            // Ensure we are not interrupting in-progress starting.
-            await started;
-            // Trigger cleanup asynchronously.
-            setImmediate(() => {
-                void cleanup();
-            });
-            return {
-                success: true,
-                message: 'stopping',
-            };
-        }
-        else if (msg.method === 'status') {
-            return {
-                success: true,
-                result: JSON.stringify({
-                    pid: process.pid,
-                    socketPath,
-                    startDate: startDate.toISOString(),
-                    version: VERSION,
-                    args: mcpServerArgs,
-                }),
-            };
-        }
-        {
-            return {
-                success: false,
-                error: `Unknown method: ${JSON.stringify(msg, null, 2)}`,
-            };
-        }
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            success: false,
-            error: errorMessage,
-        };
-    }
-}
-async function startSocketServer() {
-    // Remove existing socket file if it exists (only on non-Windows)
-    if (!IS_WINDOWS) {
-        try {
-            fs.unlinkSync(socketPath);
-        }
-        catch {
-            // ignore errors.
-        }
-    }
-    return await new Promise((resolve, reject) => {
-        server = createServer(socket => {
-            const transport = new PipeTransport(socket, socket);
-            transport.onmessage = async (message) => {
-                logger('onmessage', message);
-                const response = await handleRequest(JSON.parse(message));
-                transport.send(JSON.stringify(response));
-                socket.end();
-            };
-            socket.on('error', error => {
-                logger('Socket error:', error);
-            });
-        });
-        server.listen({
-            path: socketPath,
-            readableAll: false,
-            writableAll: false,
-        }, async () => {
-            console.log(`Daemon server listening on ${socketPath}`);
-            try {
-                // Setup MCP client
-                await setupMCPClient();
-                resolve();
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
-        server.on('error', error => {
-            logger('Server error:', error);
-            reject(error);
-        });
-    });
-}
-async function cleanup() {
-    console.log('Cleaning up daemon...');
-    try {
-        await mcpClient?.close();
-    }
-    catch (error) {
-        logger('Error closing MCP client:', error);
-    }
-    try {
-        await mcpTransport?.close();
-    }
-    catch (error) {
-        logger('Error closing MCP transport:', error);
-    }
-    if (server) {
-        await new Promise(resolve => {
-            server.close(() => resolve());
-        });
-    }
-    if (!IS_WINDOWS) {
-        try {
-            fs.unlinkSync(socketPath);
-        }
-        catch {
-            // ignore errors
-        }
-    }
-    logger(`unlinking ${pidFilePath}`);
-    if (fs.existsSync(pidFilePath)) {
-        fs.unlinkSync(pidFilePath);
-    }
-    process.exit(0);
-}
-// Handle shutdown signals
-process.on('SIGTERM', () => {
-    void cleanup();
-});
-process.on('SIGINT', () => {
-    void cleanup();
-});
-process.on('SIGHUP', () => {
-    void cleanup();
-});
-// Handle uncaught errors
-process.on('uncaughtException', error => {
-    logger('Uncaught exception:', error);
-});
-process.on('unhandledRejection', error => {
-    logger('Unhandled rejection:', error);
-});
-// Start the server
-const started = startSocketServer().catch(error => {
-    logger('Failed to start daemon server:', error);
-    process.exit(1);
-});

package/build/src/daemon/types.js

@@ -1,6 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-export {};

package/build/src/daemon/utils.js

@@ -1,108 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import process from 'node:process';
-import { logger } from '../logger.js';
-export const DAEMON_SCRIPT_PATH = path.join(import.meta.dirname, 'daemon.js');
-export const INDEX_SCRIPT_PATH = path.join(import.meta.dirname, '..', 'bin', 'chrome-devtools-mcp.js');
-const APP_NAME = 'chrome-devtools-mcp';
-// Using these paths due to strict limits on the POSIX socket path length.
-export function getSocketPath() {
-    const uid = os.userInfo().uid;
-    if (IS_WINDOWS) {
-        // Windows uses Named Pipes, not file paths.
-        // This format is required for server.listen()
-        return path.join('\\\\.\\pipe', APP_NAME, 'server.sock');
-    }
-    // 1. Try XDG_RUNTIME_DIR (Linux standard, sometimes macOS)
-    if (process.env.XDG_RUNTIME_DIR) {
-        return path.join(process.env.XDG_RUNTIME_DIR, APP_NAME, 'server.sock');
-    }
-    // 2. macOS/Unix Fallback: Use /tmp/
-    // We use /tmp/ because it is much shorter than ~/Library/Application Support/
-    // and keeps us well under the 104-character limit.
-    return path.join('/tmp', `${APP_NAME}-${uid}.sock`);
-}
-export function getRuntimeHome() {
-    const platform = os.platform();
-    const uid = os.userInfo().uid;
-    // 1. Check for the modern Unix standard
-    if (process.env.XDG_RUNTIME_DIR) {
-        return path.join(process.env.XDG_RUNTIME_DIR, APP_NAME);
-    }
-    // 2. Fallback for macOS and older Linux
-    if (platform === 'darwin' || platform === 'linux') {
-        // /tmp is cleared on boot, making it perfect for PIDs
-        return path.join('/tmp', `${APP_NAME}-${uid}`);
-    }
-    // 3. Windows Fallback
-    return path.join(os.tmpdir(), APP_NAME);
-}
-export const IS_WINDOWS = os.platform() === 'win32';
-export function getPidFilePath() {
-    const runtimeDir = getRuntimeHome();
-    return path.join(runtimeDir, 'daemon.pid');
-}
-export function getDaemonPid() {
-    try {
-        const pidFile = getPidFilePath();
-        logger(`Daemon pid file ${pidFile}`);
-        if (!fs.existsSync(pidFile)) {
-            return null;
-        }
-        const pidContent = fs.readFileSync(pidFile, 'utf-8');
-        const pid = parseInt(pidContent.trim(), 10);
-        logger(`Daemon pid: ${pid}`);
-        if (isNaN(pid)) {
-            return null;
-        }
-        return pid;
-    }
-    catch {
-        return null;
-    }
-}
-export function isDaemonRunning(pid = getDaemonPid()) {
-    if (pid) {
-        try {
-            process.kill(pid, 0); // Throws if process doesn't exist
-            return true;
-        }
-        catch {
-            // Process is dead, stale PID file. Proceed with startup.
-        }
-    }
-    return false;
-}
-export function serializeArgs(options, argv) {
-    const args = [];
-    for (const key of Object.keys(options)) {
-        if (argv[key] === undefined || argv[key] === null) {
-            continue;
-        }
-        const value = argv[key];
-        const kebabKey = key.replace(/[A-Z]/g, m => `-${m.toLowerCase()}`);
-        if (typeof value === 'boolean') {
-            if (value) {
-                args.push(`--${kebabKey}`);
-            }
-            else {
-                args.push(`--no-${kebabKey}`);
-            }
-        }
-        else if (Array.isArray(value)) {
-            for (const item of value) {
-                args.push(`--${kebabKey}`, String(item));
-            }
-        }
-        else {
-            args.push(`--${kebabKey}`, String(value));
-        }
-    }
-    return args;
-}