@mcp-b/chrome-devtools-mcp 2.0.13 → 2.2.0

package/build/src/daemon/daemon.js

@@ -0,0 +1,206 @@
+#!/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

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

package/build/src/daemon/utils.js

@@ -0,0 +1,108 @@
+/**
+ * @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;
+}

package/build/src/formatters/IssueFormatter.js

@@ -14,56 +14,10 @@ export class IssueFormatter {
         this.#options = options;
     }
     toString() {
-        const title = this.#getTitle();
-        const count = this.#issue.getAggregatedIssuesCount();
-        const idPart = this.#options.id !== undefined ? `msgid=${this.#options.id} ` : '';
-        return `${idPart}[issue] ${title} (count: ${count})`;
+        return convertIssueConciseToString(this.toJSON());
     }
     toStringDetailed() {
-        const result = [];
-        if (this.#options.id !== undefined) {
-            result.push(`ID: ${this.#options.id}`);
-        }
-        const bodyParts = [];
-        const description = this.#getDescription();
-        let processedMarkdown = description?.trim();
-        // Remove heading in order not to conflict with the whole console message response markdown
-        if (processedMarkdown?.startsWith('# ')) {
-            processedMarkdown = processedMarkdown.substring(2).trimStart();
-        }
-        if (processedMarkdown) {
-            bodyParts.push(processedMarkdown);
-        }
-        else {
-            bodyParts.push(this.#getTitle() ?? 'Unknown Issue');
-        }
-        const links = this.#issue.getDescription()?.links;
-        if (links && links.length > 0) {
-            bodyParts.push('Learn more:');
-            for (const link of links) {
-                bodyParts.push(`[${link.linkTitle}](${link.link})`);
-            }
-        }
-        const affectedResources = this.#getAffectedResources();
-        if (affectedResources.length) {
-            bodyParts.push('### Affected resources');
-            bodyParts.push(...affectedResources.map(item => {
-                const details = [];
-                if (item.uid) {
-                    details.push(`uid=${item.uid}`);
-                }
-                if (item.request) {
-                    details.push((typeof item.request === 'number' ? `reqid=` : 'url=') +
-                        item.request);
-                }
-                if (item.data) {
-                    details.push(`data=${JSON.stringify(item.data)}`);
-                }
-                return details.join(' ');
-            }));
-        }
-        result.push(`Message: issue> ${bodyParts.join('\n')}`);
-        return result.join('\n');
+        return convertIssueDetailedToString(this.toJSONDetailed());
     }
     toJSON() {
         return {
@@ -77,6 +31,7 @@ export class IssueFormatter {
         return {
             id: this.#options.id,
             type: 'issue',
+            count: this.#issue.getAggregatedIssuesCount(),
             title: this.#getTitle(),
             description: this.#getDescription(),
             links: this.#issue.getDescription()?.links,
@@ -188,3 +143,50 @@ export class IssueFormatter {
         }
     }
 }
+function convertIssueConciseToString(issue) {
+    return `msgid=${issue.id} [issue] ${issue.title} (count: ${issue.count})`;
+}
+function convertIssueDetailedToString(issue) {
+    const result = [];
+    result.push(`ID: ${issue.id}`);
+    const bodyParts = [];
+    const description = issue.description;
+    let processedMarkdown = description?.trim();
+    // Remove heading in order not to conflict with the whole console message response markdown
+    if (processedMarkdown?.startsWith('# ')) {
+        processedMarkdown = processedMarkdown.substring(2).trimStart();
+    }
+    if (processedMarkdown) {
+        bodyParts.push(processedMarkdown);
+    }
+    else {
+        bodyParts.push(issue.title ?? 'Unknown Issue');
+    }
+    const links = issue.links;
+    if (links && links.length > 0) {
+        bodyParts.push('Learn more:');
+        for (const link of links) {
+            bodyParts.push(`[${link.linkTitle}](${link.link})`);
+        }
+    }
+    const affectedResources = issue.affectedResources;
+    if (affectedResources.length) {
+        bodyParts.push('### Affected resources');
+        bodyParts.push(...affectedResources.map(item => {
+            const details = [];
+            if (item.uid) {
+                details.push(`uid=${item.uid}`);
+            }
+            if (item.request) {
+                details.push((typeof item.request === 'number' ? `reqid=` : 'url=') +
+                    item.request);
+            }
+            if (item.data) {
+                details.push(`data=${JSON.stringify(item.data)}`);
+            }
+            return details.join(' ');
+        }));
+    }
+    result.push(`Message: issue> ${bodyParts.join('\n')}`);
+    return result.join('\n');
+}