@nimbus21.ai/chrome-devtools-mcp 0.17.4 → 0.17.6

package/build/src/McpContext.js

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -68,6 +69,12 @@ export class McpContext {
     #traceResults = [];
     #locatorClass;
     #options;
+    // Idle page reaper: tracks last activity time per page.
+    static PAGE_IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+    static IDLE_CHECK_INTERVAL_MS = 60 * 1000; // 60 seconds
+    #pageLastActivity = new Map();
+    #idleReaperTimer;
+    #onIdleBrowserEmpty;
     #uniqueBackendNodeIdToMcpId = new Map();
     constructor(browser, logger, options, locatorClass) {
         this.browser = browser;
@@ -97,14 +104,104 @@ export class McpContext {
         await this.#devtoolsUniverseManager.init(pages);
     }
     dispose() {
+        this.stopIdlePageReaper();
         this.#networkCollector.dispose();
         this.#consoleCollector.dispose();
         this.#devtoolsUniverseManager.dispose();
     }
+    /**
+     * Record activity on a page, resetting its idle timer.
+     */
+    touchPage(page) {
+        this.#pageLastActivity.set(page, Date.now());
+    }
+    /**
+     * Record activity on all currently tracked pages.
+     */
+    touchAllPages() {
+        const now = Date.now();
+        for (const page of this.#pages) {
+            this.#pageLastActivity.set(page, now);
+        }
+    }
+    /**
+     * Start the periodic idle page reaper.
+     * @param onBrowserEmpty - called when all pages have been closed by the reaper.
+     */
+    startIdlePageReaper(onBrowserEmpty) {
+        this.#onIdleBrowserEmpty = onBrowserEmpty;
+        // Initialize activity timestamps for all existing pages.
+        const now = Date.now();
+        for (const page of this.#pages) {
+            if (!this.#pageLastActivity.has(page)) {
+                this.#pageLastActivity.set(page, now);
+            }
+        }
+        this.#idleReaperTimer = setInterval(() => {
+            void this.#reapIdlePages();
+        }, _a.IDLE_CHECK_INTERVAL_MS);
+        // Don't keep the process alive just for the reaper.
+        this.#idleReaperTimer.unref();
+    }
+    stopIdlePageReaper() {
+        if (this.#idleReaperTimer) {
+            clearInterval(this.#idleReaperTimer);
+            this.#idleReaperTimer = undefined;
+        }
+    }
+    async #reapIdlePages() {
+        const now = Date.now();
+        const idleTimeout = _a.PAGE_IDLE_TIMEOUT_MS;
+        // Refresh page list from browser to get accurate state.
+        let pages;
+        try {
+            pages = await this.createPagesSnapshot();
+        }
+        catch {
+            return; // Browser may be disconnected.
+        }
+        const pagesToClose = [];
+        for (const page of pages) {
+            const lastActivity = this.#pageLastActivity.get(page);
+            // Pages without a recorded timestamp get one now (first seen).
+            if (lastActivity === undefined) {
+                this.#pageLastActivity.set(page, now);
+                continue;
+            }
+            if (now - lastActivity > idleTimeout) {
+                pagesToClose.push(page);
+            }
+        }
+        if (pagesToClose.length === 0) {
+            return;
+        }
+        // Close idle pages. If ALL pages are idle, close them all.
+        for (const page of pagesToClose) {
+            try {
+                this.logger(`Closing idle page ${this.#pageIdMap.get(page)}: ${page.url()} (idle ${Math.round((now - (this.#pageLastActivity.get(page) ?? now)) / 1000)}s)`);
+                this.#pageLastActivity.delete(page);
+                await page.close({ runBeforeUnload: false });
+            }
+            catch {
+                // Page may already be closed.
+            }
+        }
+        // Refresh after closing.
+        try {
+            pages = await this.createPagesSnapshot();
+        }
+        catch {
+            pages = [];
+        }
+        if (pages.length === 0 && this.#onIdleBrowserEmpty) {
+            this.logger('All pages closed by idle reaper, triggering browser cleanup');
+            this.#onIdleBrowserEmpty();
+        }
+    }
     static async from(browser, logger, opts, 
     /* Let tests use unbundled Locator class to avoid overly strict checks within puppeteer that fail when mixing bundled and unbundled class instances */
     locatorClass = Locator) {
-        const context = new McpContext(browser, logger, opts, locatorClass);
+        const context = new _a(browser, logger, opts, locatorClass);
         await context.#init();
         return context;
     }
@@ -166,7 +263,7 @@ export class McpContext {
     async newPage(background) {
         const page = await this.browser.newPage({ background });
         await this.createPagesSnapshot();
-        this.selectPage(page);
+        this.selectPage(page); // Also touches the page via selectPage.
         this.#networkCollector.addPage(page);
         this.#consoleCollector.addPage(page);
         return page;
@@ -306,6 +403,7 @@ export class McpContext {
             });
         }
         this.#selectedPage = newPage;
+        this.touchPage(newPage);
         newPage.on('dialog', this.#dialogHandler);
         this.#updateSelectedPageTimeouts();
         void newPage.emulateFocusedPage(true).catch(error => {
@@ -601,3 +699,4 @@ export class McpContext {
         return this.#extensionRegistry.getById(id);
     }
 }
+_a = McpContext;

package/build/src/browser.js

@@ -13,6 +13,36 @@ import { puppeteer } from './third_party/index.js';
 // Add stealth plugin
 puppeteerExtra.use(StealthPlugin());
 let browser;
+/**
+ * Close the browser instance, killing the Chrome process if we launched it.
+ * Safe to call multiple times or when no browser exists.
+ */
+export async function closeBrowser() {
+    if (!browser) {
+        return;
+    }
+    const b = browser;
+    browser = undefined;
+    try {
+        if (b.connected) {
+            // browser.close() sends a Browser.close CDP command and kills the process
+            // if it was launched by puppeteer. For connected browsers it just disconnects.
+            await b.close();
+        }
+    }
+    catch {
+        // Best-effort: if close fails, try to kill the process directly
+        try {
+            const proc = b.process();
+            if (proc && !proc.killed) {
+                proc.kill('SIGKILL');
+            }
+        }
+        catch {
+            // Nothing more we can do
+        }
+    }
+}
 function makeTargetFilter() {
     const ignoredPrefixes = new Set([
         'chrome://',

package/build/src/main.js

@@ -5,7 +5,7 @@
  */
 import './polyfill.js';
 import process from 'node:process';
-import { ensureBrowserConnected, ensureBrowserLaunched } from './browser.js';
+import { closeBrowser, ensureBrowserConnected, ensureBrowserLaunched } from './browser.js';
 import { cliOptions, parseArguments } from './cli.js';
 import { loadIssueDescriptions } from './issue-descriptions.js';
 import { logger, saveLogsToFile } from './logger.js';
@@ -88,11 +88,20 @@ async function getContext() {
             enableExtensions: args.categoryExtensions,
         });
     if (context?.browser !== browser) {
+        // Stop the old reaper before creating a new context.
+        context?.stopIdlePageReaper();
         context = await McpContext.from(browser, logger, {
             experimentalDevToolsDebugging: devtools,
             experimentalIncludeAllPages: args.experimentalIncludeAllPages,
             performanceCrux: args.performanceCrux,
         });
+        // Start idle page reaper: closes pages idle for 5+ minutes.
+        // When all pages are closed, kill the browser entirely.
+        // On the next tool call, getContext() will relaunch transparently.
+        context.startIdlePageReaper(() => {
+            logger('Idle reaper: all pages closed, shutting down browser');
+            void closeBrowser();
+        });
     }
     return context;
 }
@@ -147,6 +156,13 @@ function registerTool(tool) {
             logger(`${tool.name} request: ${JSON.stringify(params, null, '  ')}`);
             const context = await getContext();
             logger(`${tool.name} context: resolved`);
+            // Mark the selected page as active to prevent idle reaper from closing it.
+            try {
+                context.touchPage(context.getSelectedPage());
+            }
+            catch {
+                // No page selected yet — that's fine.
+            }
             await context.detectOpenDevToolsWindows();
             const response = new McpResponse();
             await tool.handler({
@@ -195,6 +211,43 @@ await loadIssueDescriptions();
 const transport = new StdioServerTransport();
 await server.connect(transport);
 logger('Chrome DevTools MCP Server connected');
+// Graceful shutdown: kill Chrome when the MCP server exits for any reason.
+let shuttingDown = false;
+async function gracefulShutdown(reason) {
+    if (shuttingDown) {
+        return;
+    }
+    shuttingDown = true;
+    logger(`Shutting down: ${reason}`);
+    try {
+        context?.dispose();
+    }
+    catch {
+        // best-effort
+    }
+    try {
+        await closeBrowser();
+    }
+    catch {
+        // best-effort
+    }
+    logger('Shutdown complete');
+    process.exit(0);
+}
+// Handle OS signals (container stop, systemd, Ctrl+C)
+for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
+    process.on(signal, () => {
+        void gracefulShutdown(`received ${signal}`);
+    });
+}
+// Handle MCP client disconnect (transport/server close)
+server.server.onclose = () => {
+    void gracefulShutdown('MCP client disconnected');
+};
+// Handle stdin closing (parent process died)
+process.stdin.on('close', () => {
+    void gracefulShutdown('stdin closed');
+});
 logDisclaimers();
 void clearcutLogger?.logDailyActiveIfNeeded();
 void clearcutLogger?.logServerStart(computeFlagUsage(args, cliOptions));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimbus21.ai/chrome-devtools-mcp",
-  "version": "0.17.4",
+  "version": "0.17.6",
   "description": "MCP server for Chrome DevTools with stealth mode support",
   "type": "module",
   "bin": "./build/src/index.js",