chrome-devtools-mcp 0.22.0 → 0.23.0

package/build/src/bin/chrome-devtools.js

@@ -15,9 +15,9 @@ import { VERSION } from '../version.js';
 import { commands } from './chrome-devtools-cli-options.js';
 import { cliOptions, parseArguments } from './chrome-devtools-mcp-cli-options.js';
 await checkForUpdates('Run `npm install -g chrome-devtools-mcp@latest` and `chrome-devtools start` to update and restart the daemon.');
-async function start(args) {
+async function start(args, sessionId) {
     const combinedArgs = [...args, ...defaultArgs];
-    await startDaemon(combinedArgs);
+    await startDaemon(combinedArgs, sessionId);
     logDisclaimers(parseArguments(VERSION, combinedArgs));
 }
 const defaultArgs = ['--viaCli', '--experimentalStructuredContent'];
@@ -56,6 +56,12 @@ const y = yargs(hideBin(process.argv))
     .showHelpOnFail(true)
     .usage('chrome-devtools <command> [...args] --flags')
     .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()
@@ -65,8 +71,8 @@ y.command('start', 'Start or restart chrome-devtools-mcp', y => y
     .options(startCliOptions)
     .example('$0 start --browserUrl http://localhost:9222', 'Start the server connecting to an existing browser')
     .strict(), async (argv) => {
-    if (isDaemonRunning()) {
-        await stopDaemon();
+    if (isDaemonRunning(argv.sessionId)) {
+        await stopDaemon(argv.sessionId);
     }
     // Defaults but we do not want to affect the yargs conflict resolution.
     if (argv.isolated === undefined && argv.userDataDir === undefined) {
@@ -76,15 +82,15 @@ y.command('start', 'Start or restart chrome-devtools-mcp', y => y
         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',
-        });
+        }, argv.sessionId);
         if (response.success) {
             const data = JSON.parse(response.result);
             console.log(`pid=${data.pid} socket=${data.socketPath} start-date=${data.startDate} version=${data.version}`);
@@ -100,11 +106,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;
+    if (!isDaemonRunning(sessionId)) {
         process.exit(0);
     }
-    await stopDaemon();
+    await stopDaemon(sessionId);
     process.exit(0);
 });
 for (const [commandName, commandDef] of Object.entries(commands)) {
@@ -159,9 +166,10 @@ for (const [commandName, commandDef] of Object.entries(commands)) {
             }
         }
     }, async (argv) => {
+        const sessionId = argv.sessionId;
         try {
-            if (!isDaemonRunning()) {
-                await start([]);
+            if (!isDaemonRunning(sessionId)) {
+                await start([], sessionId);
             }
             const commandArgs = {};
             for (const argName of Object.keys(args)) {
@@ -173,7 +181,7 @@ for (const [commandName, commandDef] of Object.entries(commands)) {
                 method: 'invoke_tool',
                 tool: commandName,
                 args: commandArgs,
-            });
+            }, sessionId);
             if (response.success) {
                 console.log(await handleResponse(JSON.parse(response.result), argv['output-format']));
             }

package/build/src/daemon/client.js

@@ -48,12 +48,12 @@ function waitForFile(filePath, removed = false) {
         });
     });
 }
-export async function startDaemon(mcpArgs = []) {
-    if (isDaemonRunning()) {
+export async function startDaemon(mcpArgs = [], sessionId) {
+    if (isDaemonRunning(sessionId)) {
         logger('Daemon is already running');
         return;
     }
-    const pidFilePath = getPidFilePath();
+    const pidFilePath = getPidFilePath(sessionId);
     if (fs.existsSync(pidFilePath)) {
         fs.unlinkSync(pidFilePath);
     }
@@ -61,7 +61,7 @@ export async function startDaemon(mcpArgs = []) {
     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,
     });
@@ -72,8 +72,8 @@ const SEND_COMMAND_TIMEOUT = 60_000; // ms
 /**
  * `sendCommand` opens a socket connection sends a single command and disconnects.
  */
-export async function sendCommand(command) {
-    const socketPath = getSocketPath();
+export async function sendCommand(command, sessionId) {
+    const socketPath = getSocketPath(sessionId);
     const socket = net.createConnection({
         path: socketPath,
     });
@@ -102,13 +102,13 @@ export async function sendCommand(command) {
         transport.send(JSON.stringify(command));
     });
 }
-export async function stopDaemon() {
-    if (!isDaemonRunning()) {
+export async function stopDaemon(sessionId) {
+    if (!isDaemonRunning(sessionId)) {
         logger('Daemon is not running');
         return;
     }
-    const pidFilePath = getPidFilePath();
-    await sendCommand({ method: 'stop' });
+    const pidFilePath = getPidFilePath(sessionId);
+    await sendCommand({ method: 'stop' }, sessionId);
     await waitForFile(pidFilePath, /*removed=*/ true);
 }
 export async function handleResponse(response, format) {

package/build/src/daemon/daemon.js

@@ -11,19 +11,20 @@ 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, getDaemonPid, getPidFilePath, getSocketPath, INDEX_SCRIPT_PATH, IS_WINDOWS, isDaemonRunning, } from './utils.js';
-const pid = getDaemonPid();
-if (isDaemonRunning(pid)) {
+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();
+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);
 let mcpClient = null;

package/build/src/daemon/utils.js

@@ -13,46 +13,50 @@ export const INDEX_SCRIPT_PATH = path.join(import.meta.dirname, '..', 'bin', 'ch
 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() {
+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', 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() {
+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, 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) {
+    const runtimeDir = getRuntimeHome(sessionId);
     return path.join(runtimeDir, 'daemon.pid');
 }
-export function getDaemonPid() {
+export function getDaemonPid(sessionId) {
     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;
         }
@@ -68,7 +72,8 @@ export function getDaemonPid() {
         return null;
     }
 }
-export function isDaemonRunning(pid = getDaemonPid()) {
+export function isDaemonRunning(sessionId) {
+    const pid = getDaemonPid(sessionId);
     if (pid) {
         try {
             process.kill(pid, 0); // Throws if process doesn't exist

package/build/src/third_party/THIRD_PARTY_NOTICES

@@ -1,3 +1,30 @@
+Name: urlpattern-polyfill
+URL: https://github.com/kenchris/urlpattern-polyfill
+Version: 10.1.0
+License: MIT
+
+Copyright 2020 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+-------------------- DEPENDENCY DIVIDER --------------------
+
 Name: core-js
 URL: https://core-js.io
 Version: 3.49.0

package/build/src/third_party/bundled-packages.json

@@ -5,6 +5,7 @@
   "debug": "4.4.3",
   "lighthouse": "13.1.0",
   "semver": "^7.7.4",
+  "urlpattern-polyfill": "^10.1.0",
   "yargs": "18.0.0",
   "puppeteer-core": "24.42.0"
 }