@fanboynz/network-scanner 2.0.56 → 2.0.57

package/.github/workflows/npm-publish.yml

@@ -1,13 +1,12 @@
 name: Publish to NPM
 on:
-  push:
-    branches: [ main, master ]
+  workflow_dispatch:
 
 jobs:
   publish:
     runs-on: ubuntu-latest
     permissions:
-      contents: write  # This is key!
+      contents: write
       
     steps:
       - uses: actions/checkout@v4
@@ -39,4 +38,4 @@ jobs:
       - name: Push changes
         run: git push --follow-tags
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/lib/browserhealth.js

@@ -4,7 +4,7 @@
  */
 
 const { formatLogMessage, messageColors } = require('./colorize');
-const { execSync } = require('child_process');
+const { execSync, execFile } = require('child_process');
 
 // Window cleanup delay constant
 const WINDOW_CLEANUP_DELAY_MS = 15000;
@@ -20,15 +20,35 @@ const pageCreationTracker = new Map(); // Maps page -> creation timestamp
 const pageUsageTracker = new Map(); // Maps page -> { lastActivity: timestamp, isProcessing: boolean }
 const PAGE_IDLE_THRESHOLD = 25000; // 25 seconds of inactivity before considering page safe to clean
 
+/**
+ * Race a promise against a timeout, clearing the timer when the promise resolves/rejects.
+ * Prevents leaked setTimeout handles that hold closure references until they fire.
+ * @param {Promise} promise - The operation to race
+ * @param {number} ms - Timeout in milliseconds
+ * @param {string} msg - Error message on timeout
+ * @returns {Promise} Resolves/rejects with the operation result, or rejects on timeout
+ */
+function raceWithTimeout(promise, ms, msg) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error(msg)), ms);
+  });
+  return Promise.race([promise, timeoutPromise]).finally(() => clearTimeout(timeoutId));
+}
+
+const BYTES_GB = 1073741824; // 1024^3
+const BYTES_MB = 1048576;    // 1024^2
+const BYTES_KB = 1024;
+
 /**
  * Format bytes to human readable string
  * @param {number} bytes
  * @returns {string}
  */
 function formatMemory(bytes) {
-  if (bytes >= 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
-  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  if (bytes >= BYTES_GB) return `${(bytes / BYTES_GB).toFixed(1)}GB`;
+  if (bytes >= BYTES_MB) return `${(bytes / BYTES_MB).toFixed(1)}MB`;
+  if (bytes >= BYTES_KB) return `${(bytes / BYTES_KB).toFixed(1)}KB`;
   return `${bytes}B`;
 }
 
@@ -80,9 +100,6 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
         }
       } else {
         // Any page with actual content should be evaluated for closure
-        // Cache page state checks to avoid multiple browser calls
-        const isPageClosed = page.isClosed();
-
         if (cleanupMode === "all") {
           // Aggressive mode: close all content pages
           pagesToClose.push(page);
@@ -119,49 +136,31 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
       return result;
     }
     
-    // Estimate memory usage before closing
+    // Estimate memory usage before closing (parallel for performance)
     let totalEstimatedMemory = 0;
-    const pageMemoryEstimates = [];
+    const DEFAULT_PAGE_MEMORY = 8 * 1024 * 1024; // 8MB default estimate
     
-    for (let i = 0; i < pagesToClose.length; i++) {
-      const page = pagesToClose[i];
-      let pageMemoryEstimate = 0;
-      
+    const pageMemoryEstimates = await Promise.all(pagesToClose.map(async (page) => {
       try {
-        // Cache page.isClosed() check to avoid repeated browser calls
-        const isPageClosed = page.isClosed();
-        if (!isPageClosed) {
-          // Get page metrics if available
-          const metrics = await Promise.race([
-            page.metrics(),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('metrics timeout')), 1000))
-          ]);
-          
-          // Calculate memory estimate based on page metrics
-          if (metrics) {
-            // Puppeteer metrics provide various memory-related values
-            pageMemoryEstimate = (
-              (metrics.JSHeapUsedSize || 0) +           // JavaScript heap
-              (metrics.JSHeapTotalSize || 0) * 0.1 +    // Estimated overhead
-              (metrics.Nodes || 0) * 100 +              // DOM nodes (rough estimate)
-              (metrics.JSEventListeners || 0) * 50      // Event listeners
-            );
-          } else {
-            // Fallback: rough estimate based on page complexity
-            pageMemoryEstimate = 8 * 1024 * 1024; // 8MB default estimate per page
-          }
+        if (page.isClosed()) return 0;
+        const metrics = await raceWithTimeout(
+          page.metrics(), 1000, 'metrics timeout'
+        );
+        if (metrics) {
+          return (
+            (metrics.JSHeapUsedSize || 0) +
+            (metrics.JSHeapTotalSize || 0) * 0.1 +
+            (metrics.Nodes || 0) * 100 +
+            (metrics.JSEventListeners || 0) * 50
+          );
         }
+        return DEFAULT_PAGE_MEMORY;
       } catch (metricsErr) {
-        // Fallback estimate if metrics fail
-        pageMemoryEstimate = 8 * 1024 * 1024; // 8MB default
-        if (forceDebug) {
-          console.log(formatLogMessage('debug', `[group_window_cleanup] Could not get metrics for page ${i + 1}, using default estimate: ${metricsErr.message}`));
-        }
+        return DEFAULT_PAGE_MEMORY;
       }
-      
-      pageMemoryEstimates.push(pageMemoryEstimate);
-      totalEstimatedMemory += pageMemoryEstimate;
-    }
+    }));
+    
+    totalEstimatedMemory = pageMemoryEstimates.reduce((sum, mem) => sum + mem, 0);
     
     // Close identified old/unused pages
     const closePromises = pagesToClose.map(async (page, index) => {
@@ -188,10 +187,15 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
     });
     
     const closeResults = await Promise.all(closePromises);
-    const successfulCloses = closeResults.filter(result => result.success === true).length;
-    const actualMemoryFreed = closeResults
-      .filter(result => result.success === true)
-      .reduce((sum, result) => sum + (result.estimatedMemory || 0), 0);
+    // Single-pass count + sum (avoids 2 intermediate array allocations from .filter())
+    let successfulCloses = 0;
+    let actualMemoryFreed = 0;
+    for (let i = 0; i < closeResults.length; i++) {
+      if (closeResults[i].success === true) {
+        successfulCloses++;
+        actualMemoryFreed += closeResults[i].estimatedMemory || 0;
+      }
+    }
     
     if (forceDebug) {
       console.log(formatLogMessage('debug', `[group_window_cleanup] Closed ${successfulCloses}/${pagesToClose.length} old windows for completed group: ${groupDescription} after ${WINDOW_CLEANUP_DELAY_MS}ms delay`));
@@ -241,39 +245,33 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
  */
 async function isPageSafeToClose(page, forceDebug) {
   try {
-    // Cache page.isClosed() to avoid repeated browser communication
-    const isPageClosed = page.isClosed();
-    if (isPageClosed) {
+    if (page.isClosed()) {
       return true; // Already closed
     }
 
   // EXTRA SAFETY: Never close pages that might be in injection process
+  const now = Date.now();
   try {
-    // Cache page.url() for safety checks
     const pageUrl = page.url();
-    if (pageUrl && pageUrl !== 'about:blank' && Date.now() - (pageCreationTracker.get(page) || 0) < 30000) {
+    if (pageUrl && pageUrl !== 'about:blank' && now - (pageCreationTracker.get(page) || 0) < 30000) {
       return false; // Don't close recently created pages (within 30 seconds)
     }
   } catch (err) { /* ignore */ }
 
     const usage = pageUsageTracker.get(page);
     if (!usage) {
-      // No usage data - assume safe if page exists for a while
       return true;
     }
 
-    // Check if page is actively processing
     if (usage.isProcessing) {
       if (forceDebug) {
-        // Cache URL for debug logging
         const pageUrl = page.url();
         console.log(formatLogMessage('debug', `[realtime_cleanup] Page still processing: ${pageUrl.substring(0, 50)}...`));
       }
       return false;
     }
 
-    // Check if page has been idle long enough
-    const idleTime = Date.now() - usage.lastActivity;
+    const idleTime = now - usage.lastActivity;
     const isSafe = idleTime >= PAGE_IDLE_THRESHOLD;
     
     if (!isSafe && forceDebug) {
@@ -296,13 +294,15 @@ async function isPageSafeToClose(page, forceDebug) {
  */
 function updatePageUsage(page, isProcessing = false) {
   try {
-    // Cache page.isClosed() to avoid repeated calls
-    const isPageClosed = page.isClosed();
-    if (!isPageClosed) {
-      pageUsageTracker.set(page, {
-        lastActivity: Date.now(),
-        isProcessing: isProcessing
-      });
+    if (!page.isClosed()) {
+      const existing = pageUsageTracker.get(page);
+      if (existing) {
+        // Mutate in place -- same hidden class, no GC pressure
+        existing.lastActivity = Date.now();
+        existing.isProcessing = isProcessing;
+      } else {
+        pageUsageTracker.set(page, { lastActivity: Date.now(), isProcessing: isProcessing });
+      }
     }
   } catch (err) {
     // Ignore errors in usage tracking
@@ -320,8 +320,6 @@ function updatePageUsage(page, isProcessing = false) {
  */
 async function performRealtimeWindowCleanup(browserInstance, threshold = REALTIME_CLEANUP_THRESHOLD, forceDebug, totalDelay = 19000) {
   try {
-    const allPages = await browserInstance.pages();
-    
     // Initialize result object with consistent shape
     const result = {
       success: false,
@@ -334,13 +332,22 @@ async function performRealtimeWindowCleanup(browserInstance, threshold = REALTIM
       error: null
     };
     
+    // Quick count check before waiting (avoid the expensive delay if unnecessary)
+    let quickPages;
+    try {
+      quickPages = await browserInstance.pages();
+    } catch (e) {
+      result.error = e.message;
+      return result;
+    }
+    
     // Skip cleanup if we don't have enough pages to warrant it
-    if (allPages.length <= Math.max(threshold, REALTIME_CLEANUP_MIN_PAGES)) {
+    if (quickPages.length <= Math.max(threshold, REALTIME_CLEANUP_MIN_PAGES)) {
       if (forceDebug) {
-        console.log(formatLogMessage('debug', `[realtime_cleanup] Only ${allPages.length} pages open, threshold is ${threshold} - no cleanup needed`));
+        console.log(formatLogMessage('debug', `[realtime_cleanup] Only ${quickPages.length} pages open, threshold is ${threshold} - no cleanup needed`));
       }
       result.success = true;
-      result.totalPages = allPages.length;
+      result.totalPages = quickPages.length;
       result.reason = 'below_threshold';
       return result;
     }
@@ -509,23 +516,35 @@ async function isPageFromPreviousScan(page, forceDebug) {
       return false; // Don't close blank pages here, handled separately
     }
     
-    // Check if page has been idle (no recent navigation)
-    // This is a heuristic - pages from previous scans are likely to be idle
-    try {
-      const title = await page.title();
-      // Pages with generic titles or error states are likely old
-      if (title.includes('404') || 
-          title.includes('Error') || 
-          title.includes('Not Found') ||
-          title === '') {
-        return true;
-      }
-    } catch (titleErr) {
-      // If we can't get title, page might be in bad state
+    // Use tracker timestamp instead of expensive page.title() CDP call
+    const now = Date.now();
+    const createdAt = pageCreationTracker.get(page);
+    if (createdAt && now - createdAt > 120000) {
+      // Page is older than 2 minutes -- likely from a previous scan
       return true;
     }
     
-    // Default: consider most content pages as potentially old in conservative mode
+    // Check usage tracker -- idle pages are likely old
+    const usage = pageUsageTracker.get(page);
+    if (usage && !usage.isProcessing && now - usage.lastActivity > 60000) {
+      return true; // Idle for over 60 seconds
+    }
+    
+    // Fallback: only use page.title() if trackers have no data
+    if (!createdAt && !usage) {
+      try {
+        const title = await page.title();
+        if (title.includes('404') || 
+            title.includes('Error') || 
+            title.includes('Not Found') ||
+            title === '') {
+          return true;
+        }
+      } catch (titleErr) {
+        return true; // Can't get title = bad state
+      }
+    }
+    
     return false; // Conservative - don't close unless we're sure
   } catch (err) {
     if (forceDebug) {
@@ -550,6 +569,25 @@ function trackPageForRealtime(page) {
   updatePageUsage(page, false); // Initialize usage tracking
 }
 
+/**
+ * Purges stale entries from tracking Maps (pages that were closed without cleanup)
+ * Should be called periodically to prevent memory leaks
+ */
+function purgeStaleTrackers() {
+  for (const [page] of pageCreationTracker) {
+    try {
+      if (page.isClosed()) {
+        pageCreationTracker.delete(page);
+        pageUsageTracker.delete(page);
+      }
+    } catch (e) {
+      // Page reference is invalid, remove it
+      pageCreationTracker.delete(page);
+      pageUsageTracker.delete(page);
+    }
+  }
+}
+
 /**
  * Quick browser responsiveness test for use during page setup
  * Designed to catch browser degradation between operations
@@ -559,12 +597,11 @@ function trackPageForRealtime(page) {
  */
 async function isQuicklyResponsive(browserInstance, timeout = 3000) {
   try {
-    await Promise.race([
-      browserInstance.version(), // Quick responsiveness test
-      new Promise((_, reject) => 
-        setTimeout(() => reject(new Error('Quick responsiveness timeout')), timeout)
-      )
-    ]);
+    await raceWithTimeout(
+      browserInstance.version(),
+      timeout,
+      'Quick responsiveness timeout'
+    );
     return true;
   } catch (error) {
     return false;
@@ -590,20 +627,18 @@ async function testNetworkCapability(browserInstance, timeout = 10000) {
 
   try {
     // Create test page
-    testPage = await Promise.race([
+    testPage = await raceWithTimeout(
       browserInstance.newPage(),
-      new Promise((_, reject) => 
-        setTimeout(() => reject(new Error('Test page creation timeout')), timeout)
-      )
-    ]);
+      timeout,
+      'Test page creation timeout'
+    );
 
     // Test network operations (the critical operation that's failing)
-    await Promise.race([
+    await raceWithTimeout(
       testPage.setRequestInterception(true),
-      new Promise((_, reject) => 
-        setTimeout(() => reject(new Error('Network.enable test timeout')), timeout)
-      )
-    ]);
+      timeout,
+      'Network.enable test timeout'
+    );
 
     // Turn off interception and close
     await testPage.setRequestInterception(false);
@@ -662,12 +697,11 @@ async function checkBrowserHealth(browserInstance, timeout = 8000) {
     }
 
     // Test 2: Try to get pages list with timeout
-    const pages = await Promise.race([
+    const pages = await raceWithTimeout(
       browserInstance.pages(),
-      new Promise((_, reject) => 
-        setTimeout(() => reject(new Error('Browser unresponsive - pages() timeout')), timeout)
-      )
-    ]);
+      timeout,
+      'Browser unresponsive - pages() timeout'
+    );
 
     healthResult.pageCount = pages.length;
     healthResult.responseTime = Date.now() - startTime;
@@ -677,23 +711,38 @@ async function checkBrowserHealth(browserInstance, timeout = 8000) {
       healthResult.recommendations.push('Too many open pages - consider browser restart');
     }
 
-    // Test 4: Try to create a test page to verify browser functionality
+    // Test 4: Create a single test page to verify both browser functionality AND network capability
     let testPage = null;
     try {
-      testPage = await Promise.race([
+      testPage = await raceWithTimeout(
         browserInstance.newPage(),
-        new Promise((_, reject) => 
-          setTimeout(() => reject(new Error('Page creation timeout')), timeout)
-        )
-      ]);
+        timeout,
+        'Page creation timeout'
+      );
 
       // Quick test navigation to about:blank
-      await Promise.race([
+      await raceWithTimeout(
         testPage.goto('about:blank'),
-        new Promise((_, reject) => 
-          setTimeout(() => reject(new Error('Navigation timeout')), timeout)
-        )
-      ]);
+        timeout,
+        'Navigation timeout'
+      );
+
+      // Test 5: Network capability test on the same page (avoids creating a second test page)
+      try {
+        await raceWithTimeout(
+          testPage.setRequestInterception(true),
+          Math.min(timeout, 5000),
+          'Network.enable test timeout'
+        );
+        await testPage.setRequestInterception(false);
+        healthResult.networkCapable = true;
+      } catch (networkErr) {
+        healthResult.networkCapable = false;
+        healthResult.recommendations.push(`Network operations failing: ${networkErr.message}`);
+        if (networkErr.message.includes('Network.enable')) {
+          healthResult.criticalError = true;
+        }
+      }
 
       await testPage.close();
       
@@ -711,24 +760,13 @@ async function checkBrowserHealth(browserInstance, timeout = 8000) {
       return healthResult;
     }
 
-    // Test 5: Network capability test (critical for Network.enable issues)
-    const networkTest = await testNetworkCapability(browserInstance, Math.min(timeout, 5000));
-    healthResult.networkCapable = networkTest.capable;
-    
-    if (!networkTest.capable) {
-      healthResult.recommendations.push(`Network operations failing: ${networkTest.error}`);
-      if (networkTest.error && networkTest.error.includes('Network.enable')) {
-        healthResult.criticalError = true;
-      }
-    }
-
     // Test 6: Check response time performance
     if (healthResult.responseTime > 5000) {
       healthResult.recommendations.push('Slow browser response - consider restart');
     }
 
     // If all tests pass (including network capability)
-    healthResult.healthy = networkTest.capable; // Network capability is now critical for health
+    healthResult.healthy = healthResult.networkCapable; // Network capability is now critical for health
 
 
   } catch (error) {
@@ -782,7 +820,12 @@ async function checkBrowserMemory(browserInstance) {
 
     // Try to get process memory info (Linux/Unix)
     try {
-      const memInfo = execSync(`ps -p ${browserProcess.pid} -o rss=`, { encoding: 'utf8', timeout: 2000 });
+      const memInfo = await new Promise((resolve, reject) => {
+        execFile('ps', ['-p', String(browserProcess.pid), '-o', 'rss='], { encoding: 'utf8', timeout: 2000 }, (err, stdout) => {
+          if (err) reject(err);
+          else resolve(stdout);
+        });
+      });
       const memoryKB = parseInt(memInfo.trim());
       
       if (!isNaN(memoryKB)) {
@@ -811,40 +854,22 @@ async function checkBrowserMemory(browserInstance) {
   return memoryResult;
 }
 
- /**
+/**
+ * Precompiled regex for critical protocol error detection (avoids array allocation per call)
+ */
+const CRITICAL_ERROR_REGEX = /Runtime\.callFunctionOn timed out|Protocol error|Target closed|Session closed|Connection closed|Browser has been closed|Runtime\.evaluate timed out|WebSocket is not open|WebSocket connection lost|Connection terminated|Network service crashed|Browser disconnected|CDP session invalid|Browser process exited|Navigation timeout of|Page crashed|Renderer process crashed|Network\.enable timed out|Network\.disable timed out|Network service not available/;
+
+/**
+ * Precompiled regex for restart recommendation detection
+ */
+const RESTART_RECOMMENDATION_REGEX = /restart required|High memory usage/;
+
+/**
  * Detects critical protocol errors that require immediate browser restart
  */
 function isCriticalProtocolError(error) {
   if (!error || !error.message) return false;
-  
-  const criticalErrors = [
-    'Runtime.callFunctionOn timed out',
-    'Protocol error',
-    'Target closed',
-    'Session closed',
-    'Connection closed',
-    'Browser has been closed',
-    'Runtime.evaluate timed out',
-    // New Puppeteer 23.x critical errors
-    'WebSocket is not open',
-    'WebSocket connection lost',
-    'Connection terminated',
-    'Network service crashed',
-    'Browser disconnected',
-    'CDP session invalid',
-    'Browser process exited',
-    'Navigation timeout of',
-    'Page crashed',
-    'Renderer process crashed',
-    // Network-specific critical errors
-    'Network.enable timed out',
-    'Network.disable timed out',
-    'Network service not available'
-  ];
-  
-  return criticalErrors.some(criticalError => 
-    error.message.includes(criticalError)
-  );
+  return CRITICAL_ERROR_REGEX.test(error.message);
 }
 
 /**
@@ -871,12 +896,11 @@ async function testBrowserConnectivity(browserInstance, timeout = 2500) {
 
     // Test 2: CDP responsiveness with version check
     try {
-      const version = await Promise.race([
+      const version = await raceWithTimeout(
         browserInstance.version(),
-        new Promise((_, reject) => 
-          setTimeout(() => reject(new Error('CDP version check timeout')), timeout)
-        )
-      ]);
+        timeout,
+        'CDP version check timeout'
+      );
       
       connectivityResult.cdpResponsive = true;
       connectivityResult.websocketHealthy = true; // If version works, WebSocket is healthy
@@ -936,12 +960,16 @@ async function performHealthAssessment(browserInstance, options = {}) {
     assessment.memory = await checkBrowserMemory(browserInstance);
   }
 
-  // Combine recommendations
-  assessment.recommendations = [
-    ...assessment.browser.recommendations,
-    ...(assessment.connectivity.error ? [`Connectivity issue: ${assessment.connectivity.error}`] : []),
-    ...(assessment.memory.recommendations || [])
-  ];
+  // Combine recommendations (push avoids spread operator intermediate arrays)
+  assessment.recommendations = assessment.browser.recommendations.slice();
+  if (assessment.connectivity.error) {
+    assessment.recommendations.push(`Connectivity issue: ${assessment.connectivity.error}`);
+  }
+  if (assessment.memory.recommendations) {
+    for (let i = 0; i < assessment.memory.recommendations.length; i++) {
+      assessment.recommendations.push(assessment.memory.recommendations[i]);
+    }
+  }
 
   // Determine overall health and restart necessity
   if (!assessment.browser.healthy) {
@@ -955,10 +983,7 @@ async function performHealthAssessment(browserInstance, options = {}) {
     assessment.needsRestart = true;
   } else if (assessment.recommendations.length > 0) {
     assessment.overall = 'degraded';
-    assessment.needsRestart = assessment.recommendations.some(rec => 
-      rec.includes('restart required') || 
-      rec.includes('High memory usage')
-    );
+    assessment.needsRestart = RESTART_RECOMMENDATION_REGEX.test(assessment.recommendations.join('|'));
   } else {
     assessment.overall = 'healthy';
     assessment.needsRestart = false;
@@ -1132,17 +1157,19 @@ async function cleanupPageBeforeReload(page, forceDebug = false) {
           } catch(e) {}
         });
       
-      // Clear all timers and intervals
+      // Clear recent timers and intervals (cap to last 1000 to avoid massive loops)
       const highestId = setTimeout(() => {}, 0);
-      for (let i = highestId; i >= 0; i--) {
+      const clearFrom = Math.max(0, highestId - 1000);
+      for (let i = highestId; i >= clearFrom; i--) {
         clearTimeout(i);
         clearInterval(i);
       }
       
-      // Stop all animations
+      // Stop recent animations
       if (typeof cancelAnimationFrame !== 'undefined') {
         const highestRAF = requestAnimationFrame(() => {});
-        for (let i = highestRAF; i >= 0; i--) {
+        const clearRAFFrom = Math.max(0, highestRAF - 200);
+        for (let i = highestRAF; i >= clearRAFFrom; i--) {
           cancelAnimationFrame(i);
         }
       }
@@ -1198,5 +1225,6 @@ module.exports = {
   isBrowserHealthy,
   isCriticalProtocolError,
   updatePageUsage,
-  cleanupPageBeforeReload
+  cleanupPageBeforeReload,
+  purgeStaleTrackers
 };