@nimbus21.ai/chrome-devtools-mcp 0.17.5 → 0.17.7

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,21 @@ 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
+    static #INTERNAL_URL_PREFIXES = [
+        'about:',
+        'chrome://',
+        'chrome-extension://',
+        'chrome-untrusted://',
+        'devtools://',
+    ];
+    #pageLastActivity = new Map();
+    #idleReaperTimer;
+    #onIdleBrowserEmpty;
+    // Tracks when we first noticed only internal pages remaining.
+    #onlyInternalPagesSince;
     #uniqueBackendNodeIdToMcpId = new Map();
     constructor(browser, logger, options, locatorClass) {
         this.browser = browser;
@@ -97,14 +113,143 @@ 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());
+        // A user is interacting with a page — reset the internal-only timer.
+        this.#onlyInternalPagesSince = undefined;
+    }
+    /**
+     * 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;
+        }
+    }
+    static #isInternalPage(page) {
+        const url = page.url();
+        return _a.#INTERNAL_URL_PREFIXES.some(prefix => url.startsWith(prefix));
+    }
+    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.
+        }
+        // Also get ALL pages from the browser (including those filtered by
+        // createPagesSnapshot) so we can detect internal-only state.
+        let allBrowserPages;
+        try {
+            allBrowserPages = await this.browser.pages(true);
+        }
+        catch {
+            return;
+        }
+        const pagesToClose = [];
+        for (const page of pages) {
+            // Skip internal pages — they can't be closed and will respawn.
+            if (_a.#isInternalPage(page)) {
+                continue;
+            }
+            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);
+            }
+        }
+        // Close idle user pages.
+        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.
+            }
+        }
+        // Re-check all browser pages to determine if only internal pages remain.
+        try {
+            allBrowserPages = await this.browser.pages(true);
+        }
+        catch {
+            allBrowserPages = [];
+        }
+        const hasUserPages = allBrowserPages.some(p => !p.isClosed() && !_a.#isInternalPage(p));
+        if (hasUserPages) {
+            // User pages still exist — reset the internal-only timer.
+            this.#onlyInternalPagesSince = undefined;
+            return;
+        }
+        // Only internal pages (or no pages) remain.
+        if (!this.#onIdleBrowserEmpty) {
+            return;
+        }
+        if (allBrowserPages.length === 0) {
+            // Truly empty — kill immediately.
+            this.logger('All pages closed by idle reaper, triggering browser cleanup');
+            this.#onIdleBrowserEmpty();
+            return;
+        }
+        // Internal pages only — start or check the grace timer.
+        if (this.#onlyInternalPagesSince === undefined) {
+            this.#onlyInternalPagesSince = now;
+            this.logger(`Only internal pages remain (${allBrowserPages.length}), starting ${idleTimeout / 1000}s grace period`);
+            return;
+        }
+        if (now - this.#onlyInternalPagesSince > idleTimeout) {
+            this.logger(`Only internal pages for ${Math.round((now - this.#onlyInternalPagesSince) / 1000)}s, triggering browser cleanup`);
+            this.#onlyInternalPagesSince = undefined;
+            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 +311,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 +451,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 +747,4 @@ export class McpContext {
         return this.#extensionRegistry.getById(id);
     }
 }
+_a = McpContext;

package/build/src/main.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({

package/package.json

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