opera-devtools-mcp 0.2.3 → 0.3.0

package/build/src/daemon/client.js

@@ -6,11 +6,13 @@
 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 { getTempFilePath } from '../utils/files.js';
+import { logger, puppeteerLogger } from '../utils/logger.js';
 import { DAEMON_SCRIPT_PATH, getSocketPath, getPidFilePath, isDaemonRunning, } from './utils.js';
 const FILE_TIMEOUT = 10_000;
+const READY_CHECK_INTERVAL = 100;
+const READY_CHECK_COMMAND_TIMEOUT = 1_000;
 /**
  * Waits for a file to be created and populated (removed = false) or removed (removed = true).
  */
@@ -48,16 +50,43 @@ function waitForFile(filePath, removed = false) {
         });
     });
 }
+function delay(ms) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}
+async function waitForDaemonReady(sessionId) {
+    const deadline = Date.now() + FILE_TIMEOUT;
+    let lastError;
+    while (Date.now() < deadline) {
+        try {
+            const response = await sendCommand({ method: 'status' }, sessionId, READY_CHECK_COMMAND_TIMEOUT);
+            if (response.success) {
+                return;
+            }
+            lastError = new Error(String(response.error));
+        }
+        catch (error) {
+            lastError = error;
+        }
+        const timeLeft = deadline - Date.now();
+        if (timeLeft > 0) {
+            await delay(Math.min(READY_CHECK_INTERVAL, timeLeft));
+        }
+    }
+    throw new Error(`Timeout: daemon not ready within ${FILE_TIMEOUT}ms`, lastError === undefined ? undefined : { cause: lastError });
+}
 export async function startDaemon(mcpArgs = [], sessionId) {
     if (isDaemonRunning(sessionId)) {
-        logger('Daemon is already running');
+        logger?.('Daemon is already running');
+        await waitForDaemonReady(sessionId);
         return;
     }
     const pidFilePath = getPidFilePath(sessionId);
     if (fs.existsSync(pidFilePath)) {
         fs.unlinkSync(pidFilePath);
     }
-    logger('Starting daemon...', ...mcpArgs);
+    logger?.('Starting daemon...', ...mcpArgs);
     const child = spawn(process.execPath, [DAEMON_SCRIPT_PATH, ...mcpArgs], {
         detached: true,
         stdio: 'ignore',
@@ -67,12 +96,17 @@ export async function startDaemon(mcpArgs = [], sessionId) {
     });
     child.unref();
     await waitForFile(pidFilePath);
+    await waitForDaemonReady(sessionId);
 }
 const SEND_COMMAND_TIMEOUT = 60_000; // ms
 /**
  * `sendCommand` opens a socket connection sends a single command and disconnects.
  */
-export async function sendCommand(command, sessionId) {
+export async function sendCommand(command, sessionId, timeout = SEND_COMMAND_TIMEOUT) {
+    // Before connecting and sending, verify the daemon is still alive.
+    if (!isDaemonRunning(sessionId)) {
+        throw new Error('Daemon is not running.');
+    }
     const socketPath = getSocketPath(sessionId);
     const socket = net.createConnection({
         path: socketPath,
@@ -81,47 +115,60 @@ export async function sendCommand(command, sessionId) {
         const timer = setTimeout(() => {
             socket.destroy();
             reject(new Error('Timeout waiting for daemon response'));
-        }, SEND_COMMAND_TIMEOUT);
-        const transport = new PipeTransport(socket, socket);
+        }, timeout);
+        const transport = new PipeTransport(socket, socket, puppeteerLogger);
         transport.onmessage = async (message) => {
             clearTimeout(timer);
-            logger('onmessage', message);
+            logger?.('onmessage', message);
             resolve(JSON.parse(message));
         };
         socket.on('error', error => {
             clearTimeout(timer);
-            logger('Socket error:', error);
+            logger?.('Socket error:', error);
             reject(error);
         });
         socket.on('close', () => {
             clearTimeout(timer);
-            logger('Socket closed:');
+            logger?.('Socket closed:');
             reject(new Error('Socket closed'));
         });
-        logger('Sending message', command);
+        logger?.('Sending message', command);
         transport.send(JSON.stringify(command));
     });
 }
 export async function stopDaemon(sessionId) {
     if (!isDaemonRunning(sessionId)) {
-        logger('Daemon is not running');
+        logger?.('Daemon is not running');
         return;
     }
     const pidFilePath = getPidFilePath(sessionId);
     await sendCommand({ method: 'stop' }, sessionId);
     await waitForFile(pidFilePath, /*removed=*/ true);
 }
+export async function verifyDaemonVersion(sessionId, cliVersion) {
+    if (!isDaemonRunning(sessionId)) {
+        return undefined;
+    }
+    try {
+        const response = await sendCommand({ method: 'status' }, sessionId);
+        if (response.success) {
+            const data = JSON.parse(response.result);
+            if (data?.version && data.version !== cliVersion) {
+                return `Warning: Daemon server version (${data.version}) does not match CLI version (${cliVersion}). Run 'chrome-devtools start' to update and restart the daemon.`;
+            }
+        }
+    }
+    catch {
+        // Suppress communication failures during check; command execution handles unreachable daemon errors.
+    }
+    return undefined;
+}
 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 = [];
+    const images = [];
     for (const content of response.content) {
         if (content.type === 'text') {
             chunks.push(content.text);
@@ -143,12 +190,23 @@ export async function handleResponse(response, format) {
             const name = crypto.randomUUID();
             const filepath = await getTempFilePath(`${name}${extension}`);
             fs.writeFileSync(filepath, data);
+            images.push({ filePath: filepath, mimeType });
             chunks.push(`Saved to ${filepath}.`);
         }
         else {
             throw new Error('Not supported response content type');
         }
     }
+    if (format === 'json') {
+        if (response.structuredContent) {
+            const structuredContent = {
+                ...response.structuredContent,
+                ...(images.length ? { images } : {}),
+            };
+            return JSON.stringify(structuredContent);
+        }
+        // Fall-through to text for backward compatibility.
+    }
     return format === 'md' ? chunks.join(' ') : JSON.stringify(chunks);
 }
 //# sourceMappingURL=client.js.map

package/build/src/daemon/daemon.js

@@ -4,26 +4,84 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import fs from 'node:fs';
+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 { logger, puppeteerLogger } from '../utils/logger.js';
 import { VERSION } from '../version.js';
-import { DAEMON_CLIENT_NAME, getPidFilePath, getSocketPath, INDEX_SCRIPT_PATH, IS_WINDOWS, isDaemonRunning, } from './utils.js';
+import { DAEMON_CLIENT_NAME, getPidFilePath, getSocketPath, INDEX_SCRIPT_PATH, IS_WINDOWS, isDaemonRunning, assertValidSessionId, } from './utils.js';
 const sessionId = process.env.CHROME_DEVTOOLS_MCP_SESSION_ID || '';
-logger(`Daemon sessionId: ${sessionId}`);
+assertValidSessionId(sessionId);
+logger?.(`Daemon sessionId: ${sessionId}`);
 if (isDaemonRunning(sessionId)) {
-    logger('Another daemon process is running.');
+    logger?.('Another daemon process is running.');
     process.exit(1);
 }
 const pidFilePath = getPidFilePath(sessionId);
-fs.mkdirSync(path.dirname(pidFilePath), {
-    recursive: true,
-});
-fs.writeFileSync(pidFilePath, process.pid.toString());
-logger(`Writing ${process.pid.toString()} to ${pidFilePath}`);
+const pidDir = path.dirname(pidFilePath);
+const currentUserUid = os.userInfo().uid;
+try {
+    fs.mkdirSync(pidDir, { recursive: true, mode: 0o700 });
+    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);
@@ -76,15 +134,17 @@ async function handleRequest(msg) {
             };
         }
         else if (msg.method === 'status') {
+            await started;
+            const statusResult = {
+                pid: process.pid,
+                socketPath,
+                startDate: startDate.toISOString(),
+                version: VERSION,
+                args: mcpServerArgs,
+            };
             return {
                 success: true,
-                result: JSON.stringify({
-                    pid: process.pid,
-                    socketPath,
-                    startDate: startDate.toISOString(),
-                    version: VERSION,
-                    args: mcpServerArgs,
-                }),
+                result: JSON.stringify(statusResult),
             };
         }
         {
@@ -114,15 +174,15 @@ async function startSocketServer() {
     }
     return await new Promise((resolve, reject) => {
         server = createServer(socket => {
-            const transport = new PipeTransport(socket, socket);
+            const transport = new PipeTransport(socket, socket, puppeteerLogger);
             transport.onmessage = async (message) => {
-                logger('onmessage', 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);
+                logger?.('Socket error:', error);
             });
         });
         server.listen({
@@ -141,24 +201,24 @@ async function startSocketServer() {
             }
         });
         server.on('error', error => {
-            logger('Server error:', error);
+            logger?.('Server error:', error);
             reject(error);
         });
     });
 }
-async function cleanup() {
+async function cleanup(exitCode = 0) {
     console.log('Cleaning up daemon...');
     try {
         await mcpClient?.close();
     }
     catch (error) {
-        logger('Error closing MCP client:', error);
+        logger?.('Error closing MCP client:', error);
     }
     try {
         await mcpTransport?.close();
     }
     catch (error) {
-        logger('Error closing MCP transport:', error);
+        logger?.('Error closing MCP transport:', error);
     }
     if (server) {
         await new Promise(resolve => {
@@ -173,11 +233,11 @@ async function cleanup() {
             // ignore errors
         }
     }
-    logger(`unlinking ${pidFilePath}`);
+    logger?.(`unlinking ${pidFilePath}`);
     if (fs.existsSync(pidFilePath)) {
         fs.unlinkSync(pidFilePath);
     }
-    process.exit(0);
+    process.exit(exitCode);
 }
 // Handle shutdown signals
 process.on('SIGTERM', () => {
@@ -191,14 +251,16 @@ process.on('SIGHUP', () => {
 });
 // Handle uncaught errors
 process.on('uncaughtException', error => {
-    logger('Uncaught exception:', error);
+    logger?.('Uncaught exception:', error);
+    void cleanup(1);
 });
 process.on('unhandledRejection', error => {
-    logger('Unhandled rejection:', error);
+    logger?.('Unhandled rejection:', error);
+    void cleanup(1);
 });
 // Start the server
 const started = startSocketServer().catch(error => {
-    logger('Failed to start daemon server:', error);
-    process.exit(1);
+    logger?.('Failed to start daemon server:', error);
+    void cleanup(1);
 });
 //# sourceMappingURL=daemon.js.map

package/build/src/daemon/utils.js

@@ -9,20 +9,32 @@ 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';
+import { logger } from '../utils/logger.js';
+import { INDEX_SCRIPT_NAME, MCP_BIN_NAME } from '../opera/branding.js';
 export const DAEMON_SCRIPT_PATH = path.join(import.meta.dirname, 'daemon.js');
-export const INDEX_SCRIPT_PATH = path.join(import.meta.dirname, '..', 'bin', 'opera-devtools-mcp.js');
-const APP_NAME = 'opera-devtools-mcp';
+export const INDEX_SCRIPT_PATH = path.join(import.meta.dirname, '..', 'bin', INDEX_SCRIPT_NAME);
+const APP_NAME = MCP_BIN_NAME;
 export const DAEMON_CLIENT_NAME = 'chrome-devtools-cli-daemon';
+export function assertValidSessionId(sessionId) {
+    if (!sessionId) {
+        return;
+    }
+    if (!/^[a-fA-F0-9-]+$/.test(sessionId)) {
+        throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+}
 // Using these paths due to strict limits on the POSIX socket path length.
 export function getSocketPath(sessionId) {
+    assertValidSessionId(sessionId);
     const uid = os.userInfo().uid;
+    const username = os.userInfo().username;
     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');
+        // Append username to prevent cross-user named pipe squatting
+        return path.join('\\\\.\\pipe', `${appName}-${username}`, 'server.sock');
     }
     // 1. Try XDG_RUNTIME_DIR (Linux standard, sometimes macOS)
     if (process.env.XDG_RUNTIME_DIR) {
@@ -34,6 +46,7 @@ export function getSocketPath(sessionId) {
     return path.join('/tmp', `${appName}-${uid}.sock`);
 }
 export function getRuntimeHome(sessionId) {
+    assertValidSessionId(sessionId);
     const platform = os.platform();
     const uid = os.userInfo().uid;
     const suffix = sessionId ? `-${sessionId}` : '';
@@ -52,19 +65,21 @@ export function getRuntimeHome(sessionId) {
 }
 export const IS_WINDOWS = os.platform() === 'win32';
 export function getPidFilePath(sessionId) {
+    assertValidSessionId(sessionId);
     const runtimeDir = getRuntimeHome(sessionId);
     return path.join(runtimeDir, 'daemon.pid');
 }
 export function getDaemonPid(sessionId) {
+    assertValidSessionId(sessionId);
     try {
         const pidFile = getPidFilePath(sessionId);
-        logger(`Daemon pid file ${pidFile} sessionId=${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}`);
+        logger?.(`Daemon pid: ${pid}`);
         if (isNaN(pid)) {
             return null;
         }
@@ -75,6 +90,7 @@ export function getDaemonPid(sessionId) {
     }
 }
 export function isDaemonRunning(sessionId) {
+    assertValidSessionId(sessionId);
     const pid = getDaemonPid(sessionId);
     if (pid) {
         try {
@@ -105,11 +121,11 @@ export function serializeArgs(options, argv) {
         }
         else if (Array.isArray(value)) {
             for (const item of value) {
-                args.push(`--${kebabKey}`, String(item));
+                args.push(`--${kebabKey}=${String(item)}`);
             }
         }
         else {
-            args.push(`--${kebabKey}`, String(value));
+            args.push(`--${kebabKey}=${String(value)}`);
         }
     }
     return args;