refactor: add support for CLI sessionIds in tests

Author: OrKoN

scripts/test.mjs

@@ -70,7 +70,6 @@ const nodeArgs = [
   '--test-reporter',
   (process.env['NODE_TEST_REPORTER'] ?? process.env['CI']) ? 'spec' : 'dot',
   '--test-force-exit',
-  '--test-concurrency=1',
   '--test',
   '--test-timeout=120000',
   ...flags,

src/bin/chrome-devtools.ts

@@ -31,9 +31,9 @@ await checkForUpdates(
   'Run `npm install -g chrome-devtools-mcp@latest` and `chrome-devtools start` to update and restart the daemon.',
 );
 
-async function start(args: string[]) {
+async function start(args: string[], sessionId: string) {
   const combinedArgs = [...args, ...defaultArgs];
-  await startDaemon(combinedArgs);
+  await startDaemon(combinedArgs, sessionId);
   logDisclaimers(parseArguments(VERSION, combinedArgs));
 }
 
@@ -78,6 +78,12 @@ const y = yargs(hideBin(process.argv))
   .usage(
     `Run 'chrome-devtools <command> --help' for help on the specific command.`,
   )
+  .option('sessionId', {
+    type: 'string',
+    description: 'Session ID for daemon scoping',
+    default: '',
+    hidden: true,
+  })
   .demandCommand()
   .version(VERSION)
   .strict()
@@ -96,7 +102,7 @@ y.command(
       )
       .strict(),
   async argv => {
-    if (isDaemonRunning()) {
+    if (isDaemonRunning(argv.sessionId)) {
       await stopDaemon();
     }
     // Defaults but we do not want to affect the yargs conflict resolution.
@@ -107,13 +113,13 @@ y.command(
       argv.headless = true;
     }
     const args = serializeArgs(cliOptions, argv);
-    await start(args);
+    await start(args, argv.sessionId);
     process.exit(0);
   },
 ).strict(); // Re-enable strict validation for other commands; this is applied to the yargs instance itself
 
-y.command('status', 'Checks if chrome-devtools-mcp is running', async () => {
-  if (isDaemonRunning()) {
+y.command('status', 'Checks if chrome-devtools-mcp is running', y => y, async argv => {
+  if (isDaemonRunning(argv.sessionId)) {
     console.log('chrome-devtools-mcp daemon is running.');
     const response = await sendCommand({
       method: 'status',
@@ -140,11 +146,12 @@ y.command('status', 'Checks if chrome-devtools-mcp is running', async () => {
   process.exit(0);
 });
 
-y.command('stop', 'Stop chrome-devtools-mcp if any', async () => {
-  if (!isDaemonRunning()) {
+y.command('stop', 'Stop chrome-devtools-mcp if any', y => y, async argv => {
+  const sessionId = argv.sessionId as string;
+  if (!isDaemonRunning(sessionId)) {
     process.exit(0);
   }
-  await stopDaemon();
+  await stopDaemon(sessionId);
   process.exit(0);
 });
 
@@ -213,9 +220,10 @@ for (const [commandName, commandDef] of Object.entries(commands)) {
       }
     },
     async argv => {
+      const sessionId = argv.sessionId as string;
       try {
-        if (!isDaemonRunning()) {
-          await start([]);
+        if (!isDaemonRunning(sessionId)) {
+          await start([], sessionId);
         }
 
         const commandArgs: Record<string, unknown> = {};
@@ -229,7 +237,7 @@ for (const [commandName, commandDef] of Object.entries(commands)) {
           method: 'invoke_tool',
           tool: commandName,
           args: commandArgs,
-        });
+        }, sessionId);
 
         if (response.success) {
           console.log(

src/daemon/client.ts

@@ -67,13 +67,13 @@ function waitForFile(filePath: string, removed = false) {
   });
 }
 
-export async function startDaemon(mcpArgs: string[] = []) {
-  if (isDaemonRunning()) {
+export async function startDaemon(mcpArgs: string[] = [], sessionId = '') {
+  if (isDaemonRunning(sessionId)) {
     logger('Daemon is already running');
     return;
   }
 
-  const pidFilePath = getPidFilePath();
+  const pidFilePath = getPidFilePath(sessionId);
 
   if (fs.existsSync(pidFilePath)) {
     fs.unlinkSync(pidFilePath);
@@ -83,7 +83,7 @@ export async function startDaemon(mcpArgs: string[] = []) {
   const child = spawn(process.execPath, [DAEMON_SCRIPT_PATH, ...mcpArgs], {
     detached: true,
     stdio: 'ignore',
-    env: process.env,
+    env: { ...process.env, CHROME_DEVTOOLS_MCP_SESSION_ID: sessionId },
     cwd: process.cwd(),
     windowsHide: true,
   });
@@ -99,8 +99,9 @@ const SEND_COMMAND_TIMEOUT = 60_000; // ms
  */
 export async function sendCommand(
   command: DaemonMessage,
+  sessionId = ''
 ): Promise<DaemonResponse> {
-  const socketPath = getSocketPath();
+  const socketPath = getSocketPath(sessionId);
 
   const socket = net.createConnection({
     path: socketPath,
@@ -133,15 +134,15 @@ export async function sendCommand(
   });
 }
 
-export async function stopDaemon() {
-  if (!isDaemonRunning()) {
+export async function stopDaemon(sessionId = '') {
+  if (!isDaemonRunning(sessionId)) {
     logger('Daemon is not running');
     return;
   }
 
-  const pidFilePath = getPidFilePath();
+  const pidFilePath = getPidFilePath(sessionId);
 
-  await sendCommand({method: 'stop'});
+  await sendCommand({method: 'stop'}, sessionId);
 
   await waitForFile(pidFilePath, /*removed=*/ true);
 }

src/daemon/daemon.ts

@@ -22,27 +22,27 @@ import {VERSION} from '../version.js';
 import type {DaemonMessage} from './types.js';
 import {
   DAEMON_CLIENT_NAME,
-  getDaemonPid,
   getPidFilePath,
   getSocketPath,
   INDEX_SCRIPT_PATH,
   IS_WINDOWS,
   isDaemonRunning,
 } from './utils.js';
 
-const pid = getDaemonPid();
-if (isDaemonRunning(pid)) {
+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();
+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 socketPath = getSocketPath();
+const socketPath = getSocketPath(sessionId);
 
 const startDate = new Date();
 const mcpServerArgs = process.argv.slice(2);

src/daemon/utils.ts

@@ -24,56 +24,60 @@ 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(): string {
+export function getSocketPath(sessionId: string): string {
   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', APP_NAME, 'server.sock');
+    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, APP_NAME, 'server.sock');
+    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', `${APP_NAME}-${uid}.sock`);
+  return path.join('/tmp', `${appName}-${uid}.sock`);
 }
 
-export function getRuntimeHome(): string {
+export function getRuntimeHome(sessionId: string): string {
   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, APP_NAME);
+    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', `${APP_NAME}-${uid}`);
+    return path.join('/tmp', `${appName}-${uid}`);
   }
 
   // 3. Windows Fallback
-  return path.join(os.tmpdir(), APP_NAME);
+  return path.join(os.tmpdir(), appName);
 }
 
 export const IS_WINDOWS = os.platform() === 'win32';
 
-export function getPidFilePath() {
-  const runtimeDir = getRuntimeHome();
+export function getPidFilePath(sessionId: string) {
+  const runtimeDir = getRuntimeHome(sessionId);
   return path.join(runtimeDir, 'daemon.pid');
 }
 
-export function getDaemonPid() {
+export function getDaemonPid(sessionId: string) {
   try {
-    const pidFile = getPidFilePath();
-    logger(`Daemon pid file ${pidFile}`);
+    const pidFile = getPidFilePath(sessionId);
+    logger(`Daemon pid file ${pidFile} sessionId=${sessionId}`);
     if (!fs.existsSync(pidFile)) {
       return null;
     }
@@ -89,7 +93,8 @@ export function getDaemonPid() {
   }
 }
 
-export function isDaemonRunning(pid = getDaemonPid()): pid is number {
+export function isDaemonRunning(sessionId: string): boolean {
+  const pid = getDaemonPid(sessionId);
   if (pid) {
     try {
       process.kill(pid, 0); // Throws if process doesn't exist

tests/daemon/client.test.ts

@@ -5,6 +5,7 @@
  */
 
 import assert from 'node:assert';
+import crypto from 'node:crypto';
 import {describe, it, afterEach, beforeEach} from 'node:test';
 
 import {
@@ -16,39 +17,42 @@ import {isDaemonRunning} from '../../src/daemon/utils.js';
 
 describe('daemon client', () => {
   describe('start/stop', () => {
+    let sessionId: string;
+
     beforeEach(async () => {
-      await stopDaemon();
+      sessionId = crypto.randomUUID();
+      await stopDaemon(sessionId);
     });
 
     afterEach(async () => {
-      await stopDaemon();
+      await stopDaemon(sessionId);
     });
 
     it('should start and stop daemon', async () => {
-      assert.ok(!isDaemonRunning(), 'Daemon should not be running initially');
+      assert.ok(!isDaemonRunning(sessionId), 'Daemon should not be running initially');
 
-      await startDaemon();
-      assert.ok(isDaemonRunning(), 'Daemon should be running after start');
+      await startDaemon([], sessionId);
+      assert.ok(isDaemonRunning(sessionId), 'Daemon should be running after start');
 
-      await stopDaemon();
-      assert.ok(!isDaemonRunning(), 'Daemon should not be running after stop');
+      await stopDaemon(sessionId);
+      assert.ok(!isDaemonRunning(sessionId), 'Daemon should not be running after stop');
     });
 
     it('should handle starting daemon when already running', async () => {
-      await startDaemon();
-      assert.ok(isDaemonRunning(), 'Daemon should be running');
+      await startDaemon([], sessionId);
+      assert.ok(isDaemonRunning(sessionId), 'Daemon should be running');
 
       // Starting again should be a no-op
-      await startDaemon();
-      assert.ok(isDaemonRunning(), 'Daemon should still be running');
+      await startDaemon([], sessionId);
+      assert.ok(isDaemonRunning(sessionId), 'Daemon should still be running');
     });
 
     it('should handle stopping daemon when not running', async () => {
-      assert.ok(!isDaemonRunning(), 'Daemon should not be running initially');
+      assert.ok(!isDaemonRunning(sessionId), 'Daemon should not be running initially');
 
       // Stopping when not running should be a no-op
-      await stopDaemon();
-      assert.ok(!isDaemonRunning(), 'Daemon should still not be running');
+      await stopDaemon(sessionId);
+      assert.ok(!isDaemonRunning(sessionId), 'Daemon should still not be running');
     });
   });