@gabrielbryk/arc-devtools-mcp 1.3.0

package/build/src/daemon/daemon.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs, { constants, openSync, writeSync, closeSync } from 'node:fs';
+import { createServer } from 'node:net';
+import os from 'node:os';
+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 { DAEMON_CLIENT_NAME, getPidFilePath, getSocketPath, INDEX_SCRIPT_PATH, IS_WINDOWS, isDaemonRunning, } from './utils.js';
+const sessionId = process.env.CHROME_DEVTOOLS_MCP_SESSION_ID || '';
+logger?.(`Daemon sessionId: ${sessionId}`);
+if (isDaemonRunning(sessionId)) {
+    logger?.('Another daemon process is running.');
+    process.exit(1);
+}
+const pidFilePath = getPidFilePath(sessionId);
+const pidDir = path.dirname(pidFilePath);
+const currentUserUid = os.userInfo().uid;
+try {
+    fs.mkdirSync(pidDir, { recursive: true });
+    if (os.platform() !== 'win32') {
+        // POSIX specific checks
+        try {
+            const stats = fs.statSync(pidDir);
+            // 1. Check Ownership: Ensure the directory is owned by the current user.
+            if (stats.uid !== currentUserUid) {
+                console.error(`[MCP Daemon] Critical error: PID directory ${pidDir} is not owned by the current user (Expected: ${currentUserUid}, Found: ${stats.uid}). Possible tampering.`);
+                process.exit(1);
+            }
+            // 2. Check Permissions: Ensure the directory is not group or world-writable.
+            // Mode is a number, e.g., 0o700. We check if bits for group/world write are set.
+            const mode = stats.mode;
+            if (mode & constants.S_IWGRP || mode & constants.S_IWOTH) {
+                console.error(`[MCP Daemon] Critical error: PID directory ${pidDir} has insecure permissions (Mode: ${mode.toString(8)}). It should not be writable by group or others.`);
+                process.exit(1);
+            }
+        }
+        catch (statErr) {
+            console.error(`[MCP Daemon] Critical error stating PID directory ${pidDir}:`, statErr);
+            process.exit(1);
+        }
+    }
+}
+catch (err) {
+    console.error(`[MCP Daemon] Critical error creating/validating PID directory: ${pidDir}`, err);
+    process.exit(1);
+}
+let fd = -1;
+try {
+    // Open the file with flags to:
+    // - O_WRONLY: Write-only
+    // - O_CREAT: Create if it doesn't exist
+    // - O_TRUNC: Truncate to zero length if it exists
+    // - O_NOFOLLOW: DO NOT follow symlinks.
+    // - 0o600: Permissions: read/write for owner, no permissions for others.
+    fd = openSync(pidFilePath, constants.O_WRONLY |
+        constants.O_CREAT |
+        constants.O_TRUNC |
+        constants.O_NOFOLLOW, 0o600);
+    writeSync(fd, process.pid.toString());
+}
+catch (err) {
+    console.error(`[MCP Daemon] Critical error writing PID file: ${pidFilePath}`, err);
+    // If openSync fails due to O_NOFOLLOW on a symlink, the error will be caught here.
+    process.exit(1);
+}
+finally {
+    if (fd !== -1) {
+        try {
+            closeSync(fd);
+        }
+        catch (err) {
+            console.error(`[MCP Daemon] Error closing PID file: ${pidFilePath}`, err);
+        }
+    }
+}
+logger?.(`Writing ${process.pid.toString()} to ${pidFilePath}`);
+const socketPath = getSocketPath(sessionId);
+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
+    mcpTransport = new StdioClientTransport({
+        command: process.execPath,
+        args: [INDEX_SCRIPT_PATH, ...mcpServerArgs],
+        env: process.env,
+    });
+    mcpClient = new Client({
+        name: DAEMON_CLIENT_NAME,
+        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);
+});
+//# sourceMappingURL=daemon.js.map

package/build/src/daemon/types.js

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/build/src/daemon/utils.js

@@ -0,0 +1,115 @@
+/**
+ * @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';
+export const DAEMON_CLIENT_NAME = 'chrome-devtools-cli-daemon';
+// Using these paths due to strict limits on the POSIX socket path length.
+export function getSocketPath(sessionId) {
+    const uid = os.userInfo().uid;
+    const suffix = sessionId ? `-${sessionId}` : '';
+    const appName = APP_NAME + suffix;
+    if (IS_WINDOWS) {
+        // Windows uses Named Pipes, not file paths.
+        // This format is required for server.listen()
+        return path.join('\\\\.\\pipe', appName, '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, appName, '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', `${appName}-${uid}.sock`);
+}
+export function getRuntimeHome(sessionId) {
+    const platform = os.platform();
+    const uid = os.userInfo().uid;
+    const suffix = sessionId ? `-${sessionId}` : '';
+    const appName = APP_NAME + suffix;
+    // 1. Check for the modern Unix standard
+    if (process.env.XDG_RUNTIME_DIR) {
+        return path.join(process.env.XDG_RUNTIME_DIR, appName);
+    }
+    // 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', `${appName}-${uid}`);
+    }
+    // 3. Windows Fallback
+    return path.join(os.tmpdir(), appName);
+}
+export const IS_WINDOWS = os.platform() === 'win32';
+export function getPidFilePath(sessionId) {
+    const runtimeDir = getRuntimeHome(sessionId);
+    return path.join(runtimeDir, 'daemon.pid');
+}
+export function getDaemonPid(sessionId) {
+    try {
+        const pidFile = getPidFilePath(sessionId);
+        logger?.(`Daemon pid file ${pidFile} sessionId=${sessionId}`);
+        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(sessionId) {
+    const pid = getDaemonPid(sessionId);
+    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;
+}
+//# sourceMappingURL=utils.js.map

package/build/src/devtools/DevToolsConnectionAdapter.js

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CDPSessionEvent } from '../third_party/index.js';
+/**
+ * This class makes a puppeteer connection look like DevTools CDPConnection.
+ *
+ * Since we connect "root" DevTools targets to specific pages, we scope everything to a puppeteer CDP session.
+ *
+ * We don't have to recursively listen for 'sessionattached' as the "root" CDP session sees all child session attached
+ * events, regardless how deeply nested they are.
+ */
+export class PuppeteerDevToolsConnection {
+    #connection;
+    #observers = new Set();
+    #sessionEventHandlers = new Map();
+    constructor(session) {
+        this.#connection = session.connection();
+        session.on(CDPSessionEvent.SessionAttached, this.#startForwardingCdpEvents.bind(this));
+        session.on(CDPSessionEvent.SessionDetached, this.#stopForwardingCdpEvents.bind(this));
+        this.#startForwardingCdpEvents(session);
+    }
+    send(method, params, sessionId) {
+        if (sessionId === undefined) {
+            throw new Error('Attempting to send on the root session. This must not happen');
+        }
+        const session = this.#connection.session(sessionId);
+        if (!session) {
+            throw new Error('Unknown session ' + sessionId);
+        }
+        // Rolled protocol version between puppeteer and DevTools doesn't necessarily match
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        return session
+            .send(method, params)
+            .then(result => ({ result }))
+            .catch(error => ({ error }));
+        /* eslint-enable @typescript-eslint/no-explicit-any */
+    }
+    observe(observer) {
+        this.#observers.add(observer);
+    }
+    unobserve(observer) {
+        this.#observers.delete(observer);
+    }
+    #startForwardingCdpEvents(session) {
+        const handler = this.#handleEvent.bind(this, session.id());
+        this.#sessionEventHandlers.set(session.id(), handler);
+        session.on('*', handler);
+    }
+    #stopForwardingCdpEvents(session) {
+        const handler = this.#sessionEventHandlers.get(session.id());
+        if (handler) {
+            session.off('*', handler);
+        }
+    }
+    #handleEvent(sessionId, type, event) {
+        if (typeof type === 'string' &&
+            type !== CDPSessionEvent.SessionAttached &&
+            type !== CDPSessionEvent.SessionDetached) {
+            this.#observers.forEach(observer => observer.onEvent({
+                method: type,
+                sessionId,
+                params: event,
+            }));
+        }
+    }
+}
+//# sourceMappingURL=DevToolsConnectionAdapter.js.map