chore: implement a daemon process

Author: OrKoN

src/daemon/daemon.ts

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'node:fs/promises';
+import {createServer, type Server} from 'node:net';
+import os from 'node:os';
+import process from 'node:process';
+
+import {Client} from '@modelcontextprotocol/sdk/client/index.js';
+import {StdioClientTransport} from '@modelcontextprotocol/sdk/client/stdio.js';
+
+import {PipeTransport} from '../third_party/index.js';
+
+import {getDaemonPaths, INDEX_SCRIPT_PATH} from './utils.js';
+
+const {pidFile: PID_FILE, socketPath: SOCKET_PATH} = await getDaemonPaths();
+
+const IS_WINDOWS = os.platform() === 'win32';
+
+let mcpClient: Client | null = null;
+let mcpTransport: StdioClientTransport | null = null;
+let server: Server | null = null;
+
+async function setupMCPClient() {
+  console.log('Setting up MCP client connection...');
+
+  const args = process.argv.slice(2);
+  // Create stdio transport for chrome-devtools-mcp
+  mcpTransport = new StdioClientTransport({
+    command: process.execPath,
+    args: [INDEX_SCRIPT_PATH, ...args],
+    env: process.env as Record<string, string>,
+  });
+  mcpClient = new Client(
+    {
+      name: 'chrome-devtools-cli-daemon',
+      // TODO: handle client version (optional).
+      version: '0.1.0',
+    },
+    {
+      capabilities: {},
+    },
+  );
+  await mcpClient.connect(mcpTransport);
+
+  console.log('MCP client connected');
+}
+
+interface McpContent {
+  type: string;
+  text?: string;
+}
+
+interface McpResult {
+  content?: McpContent[] | string;
+  text?: string;
+}
+
+interface DaemonMessage {
+  method: string;
+  tool: string;
+  args?: Record<string, unknown>;
+}
+
+async function handleRequest(msg: DaemonMessage) {
+  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 || {},
+      })) as McpResult | McpContent[];
+
+      // Extract text content from MCP response
+      let textContent = '';
+
+      // Check if result is an array of content blocks
+      if (Array.isArray(result)) {
+        textContent = result
+          .filter(block => block && block.type === 'text' && block.text)
+          .map(block => block.text)
+          .join('\n');
+      }
+      // Check if result has a content property
+      else if (result && result.content) {
+        if (Array.isArray(result.content)) {
+          // Extract text from all text-type content blocks
+          textContent = result.content
+            .filter(block => block && block.type === 'text' && block.text)
+            .map(block => block.text)
+            .join('\n');
+        } else if (typeof result.content === 'string') {
+          textContent = result.content;
+        }
+      }
+      // Check if result has a text property
+      else if (result && result.text) {
+        textContent = result.text;
+      }
+      // Check if result is a string
+      else if (typeof result === 'string') {
+        textContent = result;
+      }
+
+      // Fallback: stringify if we couldn't extract text
+      if (!textContent) {
+        textContent = JSON.stringify(result, null, 2);
+      }
+      return {
+        success: true,
+        result: textContent,
+      };
+    } else if (msg.method === 'stop') {
+      // Trigger cleanup asynchronously
+      setImmediate(() => {
+        void cleanup();
+      });
+      return {
+        success: true,
+        message: 'stopping',
+      };
+    } else {
+      return {
+        success: false,
+        error: `Unknown method: ${msg.method}`,
+      };
+    }
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: errorMessage,
+    };
+  }
+}
+
+function startSocketServer() {
+  const startServer = () => {
+    return new Promise<void>((resolve, reject) => {
+      server = createServer(socket => {
+        const transport = new PipeTransport(socket, socket);
+        transport.onmessage = async (message: string) => {
+          console.error('onmessage', message);
+          const response = await handleRequest(JSON.parse(message));
+          transport.send(JSON.stringify(response));
+          socket.end();
+        };
+        socket.on('error', error => {
+          console.error('Socket error:', error);
+        });
+      });
+
+      server.listen(SOCKET_PATH, async () => {
+        console.log(`Daemon server listening on ${SOCKET_PATH}`);
+
+        // Write PID file
+        await fs.writeFile(PID_FILE, String(process.pid), 'utf-8');
+
+        try {
+          // Setup MCP client
+          await setupMCPClient();
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+
+      server.on('error', error => {
+        console.error('Server error:', error);
+        reject(error);
+      });
+    });
+  };
+
+  // Remove existing socket file if it exists (only on non-Windows)
+  if (!IS_WINDOWS) {
+    return fs
+      .unlink(SOCKET_PATH)
+      .catch(() => {
+        // Ignore if file doesn't exist
+      })
+      .then(() => startServer());
+  } else {
+    return startServer();
+  }
+}
+
+async function cleanup() {
+  console.log('Cleaning up daemon...');
+
+  if (mcpClient) {
+    try {
+      await mcpClient.close();
+    } catch (error) {
+      console.error('Error closing MCP client:', error);
+    }
+  }
+  if (mcpTransport) {
+    try {
+      await mcpTransport.close();
+    } catch (error) {
+      console.error('Error closing MCP transport:', error);
+    }
+  }
+  if (server) {
+    server.close(() => {
+      if (!IS_WINDOWS) {
+        void fs.unlink(SOCKET_PATH).catch(() => undefined);
+      }
+    });
+  }
+  await fs.unlink(PID_FILE).catch(() => undefined);
+  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 => {
+  console.error('Uncaught exception:', error);
+});
+process.on('unhandledRejection', error => {
+  console.error('Unhandled rejection:', error);
+});
+
+// Start the server
+startSocketServer().catch(error => {
+  console.error('Failed to start daemon server:', error);
+  process.exit(1);
+});

src/daemon/utils.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+
+const _dirname = import.meta.dirname;
+
+export const DAEMON_SCRIPT_PATH = path.join(_dirname, 'daemon.js');
+export const INDEX_SCRIPT_PATH = path.join(_dirname, '..', 'index.js');
+
+function getDataHome(): string {
+  if (process.env.XDG_DATA_HOME) {
+    return process.env.XDG_DATA_HOME;
+  }
+  const platform = os.platform();
+  const home = os.homedir();
+
+  switch (platform) {
+    case 'win32':
+      return process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    case 'darwin':
+      return path.join(home, 'Library', 'Application Support');
+    default:
+      // linux, etc.
+      return path.join(home, '.local', 'share');
+  }
+}
+
+function getDaemonDir(): string {
+  const dataHome = getDataHome();
+  // Using a vendor-prefixed name for safety/standard practice
+  return path.join(dataHome, 'google', 'chrome-devtools-mcp');
+}
+
+export function getDaemonPaths() {
+  const daemonDir = getDaemonDir();
+
+  const pidFile = path.join(daemonDir, 'server.pid');
+
+  const isWindows = os.platform() === 'win32';
+  const socketPath = isWindows
+    ? '\\\\.\\pipe\\chrome-devtools-mcp-daemon'
+    : path.join(daemonDir, 'server.sock');
+
+  return {
+    pidFile,
+    socketPath,
+    daemonDir,
+  };
+}

src/third_party/index.ts

@@ -30,6 +30,7 @@ export {
 } from 'puppeteer-core';
 export {default as puppeteer} from 'puppeteer-core';
 export type * from 'puppeteer-core';
+export {PipeTransport} from 'puppeteer-core/internal/node/PipeTransport.js';
 export type {CdpPage} from 'puppeteer-core/internal/cdp/Page.js';
 export {
   resolveDefaultUserDataDir,

tests/daemon/daemon.test.ts

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'node:assert';
+import {spawn} from 'node:child_process';
+import fs from 'node:fs/promises';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import {describe, it, before} from 'node:test';
+
+import {getDaemonPaths} from '../../src/daemon/utils.js';
+
+const DAEMON_SCRIPT = path.join(
+  import.meta.dirname,
+  '..',
+  '..',
+  'src',
+  'daemon',
+  'daemon.js',
+);
+
+describe('Daemon', () => {
+  let tmpDir: string;
+
+  before(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-daemon-test-'));
+    process.env['XDG_DATA_HOME'] = tmpDir;
+    await fs.mkdir(getDaemonPaths().daemonDir, {
+      recursive: true,
+    });
+  });
+
+  it('should terminate chrome instance when transport is closed', async () => {
+    const daemonProcess = spawn(process.execPath, [DAEMON_SCRIPT], {
+      env: {
+        ...process.env,
+        XDG_DATA_HOME: tmpDir,
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    const {socketPath} = getDaemonPaths();
+    // Wait for daemon to be ready
+    await new Promise<void>((resolve, reject) => {
+      const onData = (data: Buffer) => {
+        const output = data.toString();
+        // Wait for MCP client to connect
+        if (output.includes('MCP client connected')) {
+          daemonProcess.stdout.off('data', onData);
+          resolve();
+        }
+      };
+      daemonProcess.stdout.on('data', onData);
+      daemonProcess.stderr.on('data', data => {
+        console.log('err', data.toString('utf8'));
+      });
+      daemonProcess.on('error', reject);
+      daemonProcess.on('exit', (code: number) => {
+        if (code !== 0 && code !== null) {
+          reject(new Error(`Daemon exited with code ${code}`));
+        }
+      });
+    });
+
+    const socket = net.createConnection(socketPath);
+    await new Promise<void>(resolve => socket.on('connect', resolve));
+
+    daemonProcess.kill();
+    assert.ok(daemonProcess.killed);
+  });
+});