@fanboynz/network-scanner 1.0.63 → 1.0.64

package/lib/browserhealth.js

@@ -11,7 +11,7 @@ const { formatLogMessage, messageColors } = require('./colorize');
  * @param {number} timeout - Timeout in milliseconds (default: 5000)
  * @returns {Promise<object>} Health check result
  */
-async function checkBrowserHealth(browserInstance, timeout = 5000) {
+async function checkBrowserHealth(browserInstance, timeout = 8000) {
   const healthResult = {
     healthy: false,
     pageCount: 0,
@@ -44,7 +44,7 @@ async function checkBrowserHealth(browserInstance, timeout = 5000) {
     healthResult.responseTime = Date.now() - startTime;
 
     // Test 3: Check for excessive pages (memory leak indicator)
-    if (pages.length > 20) {
+    if (pages.length > 30) {
       healthResult.recommendations.push('Too many open pages - consider browser restart');
     }
 
@@ -83,7 +83,7 @@ async function checkBrowserHealth(browserInstance, timeout = 5000) {
     }
 
     // Test 5: Check response time performance
-    if (healthResult.responseTime > 3000) {
+    if (healthResult.responseTime > 5000) {
       healthResult.recommendations.push('Slow browser response - consider restart');
     }
 
@@ -95,11 +95,19 @@ async function checkBrowserHealth(browserInstance, timeout = 5000) {
     healthResult.responseTime = Date.now() - startTime;
     
     // Categorize error types for better recommendations
-    if (error.message.includes('Runtime.callFunctionOn timed out') || 
-        error.message.includes('Protocol error') || 
-        error.message.includes('Target closed')) {
+    // Enhanced error categorization for Puppeteer 23.x
+    if (isCriticalProtocolError(error)) {
       healthResult.recommendations.push('Browser restart required - critical protocol error');
       healthResult.criticalError = true;
+    } else if (error.message.includes('WebSocket') || 
+               error.message.includes('Connection terminated') ||
+               error.message.includes('Network service crashed')) {
+      // New error types more common in Puppeteer 23.x
+      healthResult.recommendations.push('Browser restart required - connection error');
+      healthResult.criticalError = true;
+    } else if (error.message.includes('AbortError') || 
+               error.message.includes('Operation was aborted')) {
+      healthResult.recommendations.push('Browser restart recommended - operation aborted');
     } else if (error.message.includes('timeout') || error.message.includes('unresponsive')) {
       healthResult.recommendations.push('Browser restart required - unresponsive');
       healthResult.criticalError = true;
@@ -176,7 +184,18 @@ function isCriticalProtocolError(error) {
     'Session closed',
     'Connection closed',
     'Browser has been closed',
-    'Runtime.evaluate timed out'
+    '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'
   ];
   
   return criticalErrors.some(criticalError => 
@@ -184,6 +203,54 @@ function isCriticalProtocolError(error) {
   );
 }
 
+/**
+ * Enhanced browser connectivity test for Puppeteer 23.x
+ * Tests WebSocket connection and CDP session validity
+ */
+async function testBrowserConnectivity(browserInstance, timeout = 2500) {
+  const connectivityResult = {
+    connected: false,
+    cdpResponsive: false,
+    websocketHealthy: false,
+    error: null
+  };
+
+  try {
+    // Test 1: Basic browser connection
+    const isConnected = browserInstance.isConnected();
+    connectivityResult.connected = isConnected;
+    
+    if (!isConnected) {
+      connectivityResult.error = 'Browser is not connected';
+      return connectivityResult;
+    }
+
+    // Test 2: CDP responsiveness with version check
+    try {
+      const version = await Promise.race([
+        browserInstance.version(),
+        new Promise((_, reject) => 
+          setTimeout(() => reject(new Error('CDP version check timeout')), timeout)
+        )
+      ]);
+      
+      connectivityResult.cdpResponsive = true;
+      connectivityResult.websocketHealthy = true; // If version works, WebSocket is healthy
+      
+    } catch (cdpError) {
+      connectivityResult.error = `CDP not responsive: ${cdpError.message}`;
+      if (cdpError.message.includes('WebSocket')) {
+        connectivityResult.websocketHealthy = false;
+      }
+    }
+    
+  } catch (error) {
+    connectivityResult.error = error.message;
+  }
+
+  return connectivityResult;
+}
+
 /**
  * Performs comprehensive browser health assessment
  * @param {import('puppeteer').Browser} browserInstance - Puppeteer browser instance
@@ -192,8 +259,9 @@ function isCriticalProtocolError(error) {
  */
 async function performHealthAssessment(browserInstance, options = {}) {
   const {
-    timeout = 5000,
+    timeout = 8000,
     checkMemory = true,
+    testConnectivity = true,
     forceDebug = false
   } = options;
 
@@ -202,6 +270,7 @@ async function performHealthAssessment(browserInstance, options = {}) {
     timestamp: new Date().toISOString(),
     browser: {},
     memory: {},
+    connectivity: {},
     recommendations: [],
     needsRestart: false
   };
@@ -213,6 +282,11 @@ async function performHealthAssessment(browserInstance, options = {}) {
   // Browser responsiveness check
   assessment.browser = await checkBrowserHealth(browserInstance, timeout);
   
+  // Enhanced connectivity check for Puppeteer 23.x
+  if (testConnectivity) {
+    assessment.connectivity = await testBrowserConnectivity(browserInstance, timeout);
+  }
+  
   // Memory usage check (if enabled and available)
   if (checkMemory) {
     assessment.memory = await checkBrowserMemory(browserInstance);
@@ -221,6 +295,7 @@ async function performHealthAssessment(browserInstance, options = {}) {
   // Combine recommendations
   assessment.recommendations = [
     ...assessment.browser.recommendations,
+    ...(assessment.connectivity.error ? [`Connectivity issue: ${assessment.connectivity.error}`] : []),
     ...(assessment.memory.recommendations || [])
   ];
 
@@ -231,6 +306,9 @@ async function performHealthAssessment(browserInstance, options = {}) {
   } else if (assessment.browser.criticalError) {
     assessment.overall = 'critical';
     assessment.needsRestart = true;
+  } else if (testConnectivity && (!assessment.connectivity.connected || !assessment.connectivity.cdpResponsive)) {
+    assessment.overall = 'disconnected';
+    assessment.needsRestart = true;
   } else if (assessment.recommendations.length > 0) {
     assessment.overall = 'degraded';
     assessment.needsRestart = assessment.recommendations.some(rec => 
@@ -279,8 +357,9 @@ async function monitorBrowserHealth(browserInstance, context = {}, options = {})
   try {
     // Perform health assessment
     const assessment = await performHealthAssessment(browserInstance, {
-      timeout: 5000,
+      timeout: 8000,
       checkMemory: true,
+      testConnectivity: true, // Enable enhanced connectivity testing
       forceDebug
     });
 
@@ -290,15 +369,22 @@ async function monitorBrowserHealth(browserInstance, context = {}, options = {})
     if (assessment.browser.criticalError) {
       result.shouldRestart = true;
       result.reason = `Critical protocol error detected - immediate restart required`;
+    } else if (assessment.connectivity && (!assessment.connectivity.connected || !assessment.connectivity.cdpResponsive)) {
+      result.shouldRestart = true;
+      result.reason = `Browser connectivity lost - WebSocket/CDP failure`;
     } else if (assessment.needsRestart) {
       result.shouldRestart = true;
       result.reason = `Browser health: ${assessment.overall} - ${assessment.recommendations[0] || 'restart needed'}`;
     } else if (urlsSinceCleanup >= cleanupInterval) {
       result.shouldRestart = true;
       result.reason = `Scheduled cleanup after ${urlsSinceCleanup} URLs`;
-    } else if (assessment.browser.responseTime > 4000) {
+    } else if (assessment.browser.responseTime > 6000) {
+      result.shouldRestart = true;
+      result.reason = `Slow browser response: ${assessment.browser.responseTime}ms (threshold: 6000ms)`;
+    } else if (assessment.browser.pageCount > 40) {
+      // More aggressive page count monitoring for Puppeteer 23.x
       result.shouldRestart = true;
-      result.reason = `Slow browser response: ${assessment.browser.responseTime}ms`;
+      result.reason = `Too many open pages: ${assessment.browser.pageCount} (memory leak protection)`;
     }
 
     // Logging
@@ -308,7 +394,9 @@ async function monitorBrowserHealth(browserInstance, context = {}, options = {})
     }
 
     if (forceDebug && !result.shouldRestart) {
-      console.log(formatLogMessage('debug', `Browser health OK - continuing (pages: ${assessment.browser.pageCount}, response: ${assessment.browser.responseTime}ms)`));
+      const connectivity = assessment.connectivity.connected ? 'connected' : 'disconnected';
+      const cdp = assessment.connectivity.cdpResponsive ? 'responsive' : 'unresponsive';
+      console.log(formatLogMessage('debug', `Browser health OK - continuing (pages: ${assessment.browser.pageCount}, response: ${assessment.browser.responseTime}ms, ${connectivity}, CDP: ${cdp})`));
     }
 
   } catch (monitorError) {
@@ -330,8 +418,9 @@ async function monitorBrowserHealth(browserInstance, context = {}, options = {})
  */
 async function isBrowserHealthy(browserInstance) {
   try {
-    const health = await checkBrowserHealth(browserInstance, 3000);
-    return health.healthy;
+    const health = await checkBrowserHealth(browserInstance, 5000); // Faster timeout
+    const connectivity = await testBrowserConnectivity(browserInstance, 3000);
+    return health.healthy && connectivity.connected && connectivity.cdpResponsive;
   } catch (error) {
     return false;
   }
@@ -340,6 +429,7 @@ async function isBrowserHealthy(browserInstance) {
 module.exports = {
   checkBrowserHealth,
   checkBrowserMemory,
+  testBrowserConnectivity,
   performHealthAssessment,
   monitorBrowserHealth,
   isBrowserHealthy,

package/lib/cdp.js

@@ -87,8 +87,9 @@ async function createCDPSession(page, currentUrl, options = {}) {
   let cdpSession = null;
 
   try {
-    // Create CDP session - this connects to Chrome's internal debugging interface
-    cdpSession = await page.target().createCDPSession();
+    // Create CDP session using modern Puppeteer 20+ API
+    // page.target().createCDPSession() was deprecated in 19+ and removed in 20+
+    cdpSession = await page.createCDPSession();
     
     // Enable network domain - required for network event monitoring  
     await cdpSession.send('Network.enable');
@@ -140,8 +141,12 @@ async function createCDPSession(page, currentUrl, options = {}) {
     cdpSession = null; // Reset on failure
     
     // Categorize CDP errors for proper handling
+    // Enhanced error handling for Puppeteer 20+ error patterns
     if (cdpErr.message.includes('Network.enable timed out') || 
-        cdpErr.message.includes('Protocol error')) {
+        cdpErr.message.includes('Protocol error') ||
+        cdpErr.message.includes('Session closed') ||
+        cdpErr.message.includes('Target closed') ||
+        cdpErr.message.includes('Browser has been closed')) {
       // CRITICAL ERROR: Browser is broken and needs restart
       // Re-throw these errors so calling code can handle browser restart
       throw new Error(`Browser protocol broken: ${cdpErr.message}`);