@fanboynz/network-scanner 1.0.85 → 1.0.87

package/lib/browserhealth.js

@@ -5,6 +5,89 @@
 
 const { formatLogMessage, messageColors } = require('./colorize');
 
+/**
+ * Quick browser responsiveness test for use during page setup
+ * Designed to catch browser degradation between operations
+ * @param {import('puppeteer').Browser} browserInstance - Puppeteer browser instance
+ * @param {number} timeout - Timeout in milliseconds (default: 3000)
+ * @returns {Promise<boolean>} True if browser responds quickly, false otherwise
+ */
+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)
+      )
+    ]);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Tests if browser can handle network operations (like Network.enable)
+ * Creates a test page and attempts basic network setup
+ * @param {import('puppeteer').Browser} browserInstance - Puppeteer browser instance
+ * @param {number} timeout - Timeout in milliseconds (default: 10000)
+ * @returns {Promise<object>} Network capability test result
+ */
+async function testNetworkCapability(browserInstance, timeout = 10000) {
+  const result = {
+    capable: false,
+    error: null,
+    responseTime: 0
+  };
+
+  const startTime = Date.now();
+  let testPage = null;
+
+  try {
+    // Create test page
+    testPage = await Promise.race([
+      browserInstance.newPage(),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('Test page creation timeout')), timeout)
+      )
+    ]);
+
+    // Test network operations (the critical operation that's failing)
+    await Promise.race([
+      testPage.setRequestInterception(true),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('Network.enable test timeout')), timeout)
+      )
+    ]);
+
+    // Turn off interception and close
+    await testPage.setRequestInterception(false);
+    result.capable = true;
+    result.responseTime = Date.now() - startTime;
+
+  } catch (error) {
+    result.error = error.message;
+    result.responseTime = Date.now() - startTime;
+
+    // Classify the error type
+    if (error.message.includes('Network.enable') || 
+        error.message.includes('timed out') ||
+        error.message.includes('Protocol error')) {
+      result.error = `Network capability test failed: ${error.message}`;
+    }
+  } finally {
+    if (testPage && !testPage.isClosed()) {
+      try { 
+        await testPage.close(); 
+      } catch (closeErr) { 
+        /* ignore cleanup errors */ 
+      }
+    }
+  }
+
+  return result;
+}
+
 /**
  * Checks if browser instance is still responsive
  * @param {import('puppeteer').Browser} browserInstance - Puppeteer browser instance
@@ -18,7 +101,8 @@ async function checkBrowserHealth(browserInstance, timeout = 8000) {
     error: null,
     responseTime: 0,
     recommendations: [],
-    criticalError: false
+    criticalError: false,
+    networkCapable: false
   };
 
   const startTime = Date.now();
@@ -82,13 +166,25 @@ async function checkBrowserHealth(browserInstance, timeout = 8000) {
       return healthResult;
     }
 
-    // Test 5: Check response time performance
+    // 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
-    healthResult.healthy = true;
+    // If all tests pass (including network capability)
+    healthResult.healthy = networkTest.capable; // Network capability is now critical for health
+
 
   } catch (error) {
     healthResult.error = error.message;
@@ -195,7 +291,11 @@ function isCriticalProtocolError(error) {
     'Browser process exited',
     'Navigation timeout of',
     'Page crashed',
-    'Renderer process crashed'
+    'Renderer process crashed',
+    // Network-specific critical errors
+    'Network.enable timed out',
+    'Network.disable timed out',
+    'Network service not available'
   ];
   
   return criticalErrors.some(criticalError => 
@@ -413,14 +513,25 @@ async function monitorBrowserHealth(browserInstance, context = {}, options = {})
 
 /**
  * Simple health check function for quick integration
+ * Enhanced version that includes network capability testing
  * @param {import('puppeteer').Browser} browserInstance - Puppeteer browser instance
+ * @param {boolean} includeNetworkTest - Whether to test network capabilities (default: true)
  * @returns {Promise<boolean>} True if browser is healthy, false otherwise
  */
-async function isBrowserHealthy(browserInstance) {
+async function isBrowserHealthy(browserInstance, includeNetworkTest = true) {
   try {
-    const health = await checkBrowserHealth(browserInstance, 5000); // Faster timeout
+    // Quick responsiveness test first (fastest check)
+    const quickCheck = await isQuicklyResponsive(browserInstance, 2500);
+    if (!quickCheck) return false;
+    
+    // More comprehensive health check if quick test passes
+    const health = await checkBrowserHealth(browserInstance, includeNetworkTest ? 8000 : 5000);
     const connectivity = await testBrowserConnectivity(browserInstance, 3000);
-    return health.healthy && connectivity.connected && connectivity.cdpResponsive;
+    
+    const baseHealth = health.healthy && connectivity.connected && connectivity.cdpResponsive;
+    
+    // Include network capability in health assessment if requested
+    return includeNetworkTest ? (baseHealth && health.networkCapable) : baseHealth;
   } catch (error) {
     return false;
   }
@@ -430,6 +541,8 @@ module.exports = {
   checkBrowserHealth,
   checkBrowserMemory,
   testBrowserConnectivity,
+  testNetworkCapability,
+  isQuicklyResponsive,
   performHealthAssessment,
   monitorBrowserHealth,
   isBrowserHealthy,

package/lib/cloudflare.js

@@ -1,5 +1,6 @@
 /**
  * Cloudflare bypass and challenge handling module - Optimized with smart detection and adaptive timeouts
+ * Version: 2.4.1 - Bump timeout values
  * Version: 2.4.0 - Fix possible endless loops with retry logic and loop detection
  * Version: 2.3.1 - Colorize CF
  * Version: 2.3.0 - Support CF iframe challenges, and better error handling
@@ -26,9 +27,9 @@ const TIMEOUTS = {
   PAGE_EVALUATION_SAFE: 10000,     // Safe page evaluation with extra buffer
   PHISHING_CLICK: 3000,           // Timeout for clicking phishing continue button
   PHISHING_NAVIGATION: 8000,       // Wait for navigation after phishing bypass
-  JS_CHALLENGE_BUFFER: 18000,     // JS challenge with safety buffer
-  TURNSTILE_COMPLETION: 12000,    // Turnstile completion check
-  TURNSTILE_COMPLETION_BUFFER: 15000, // Turnstile completion with buffer
+  JS_CHALLENGE_BUFFER: 30000,     // JS challenge with safety buffer
+  TURNSTILE_COMPLETION: 20000,    // Turnstile completion check
+  TURNSTILE_COMPLETION_BUFFER: 25000, // Turnstile completion with buffer
   CLICK_TIMEOUT: 5000,            // Standard click operation timeout
   CLICK_TIMEOUT_BUFFER: 1000,     // Click timeout safety buffer
   NAVIGATION_TIMEOUT: 15000,      // Standard navigation timeout
@@ -52,9 +53,9 @@ const FAST_TIMEOUTS = {
   ELEMENT_INTERACTION_DELAY: 250, // Fast element interactions
   SELECTOR_WAIT: 1500,            // Fast selector waits
   TURNSTILE_OPERATION: 6000,      // Fast Turnstile operations
-  JS_CHALLENGE: 12000,            // Fast JS challenge completion
-  CHALLENGE_SOLVING: 15000,       // Fast overall challenge solving
-  CHALLENGE_COMPLETION: 3000      // Fast completion check
+  JS_CHALLENGE: 22000,            // Fast JS challenge completion
+  CHALLENGE_SOLVING: 30000,       // Fast overall challenge solving
+  CHALLENGE_COMPLETION: 8000      // Fast completion check
 };
 
 /**

package/nwss.js

@@ -1,4 +1,4 @@
-// === Network scanner script (nwss.js) v1.0.85 ===
+// === Network scanner script (nwss.js) v1.0.87 ===
 
 // puppeteer for browser automation, fs for file system operations, psl for domain parsing.
 // const pLimit = require('p-limit'); // Will be dynamically imported
@@ -120,10 +120,10 @@ function detectPuppeteerVersion() {
 // Enhanced redirect handling
 const { navigateWithRedirectHandling, handleRedirectTimeout } = require('./lib/redirect');
 // Ensure web browser is working correctly
-const { monitorBrowserHealth, isBrowserHealthy } = require('./lib/browserhealth');
+const { monitorBrowserHealth, isBrowserHealthy, isQuicklyResponsive } = require('./lib/browserhealth');
 
 // --- Script Configuration & Constants --- 
-const VERSION = '1.0.85'; // Script version
+const VERSION = '1.0.87'; // Script version
 
 // get startTime
 const startTime = Date.now();
@@ -1483,6 +1483,22 @@ function setupFrameHandling(page, forceDebug) {
       if (!page || page.isClosed()) {
         throw new Error('Failed to create valid page instance');
       }
+
+      // Additional health check after page creation but before critical setup
+      const stillHealthy = await isQuicklyResponsive(browserInstance, 3000);
+      
+      if (!stillHealthy) {
+        if (forceDebug) {
+          console.log(formatLogMessage('debug', `Browser unresponsive during page setup for ${currentUrl} - triggering restart`));
+        }
+        return { 
+          url: currentUrl, 
+          rules: [], 
+          success: false, 
+          needsImmediateRestart: true,
+          error: 'Browser became unresponsive during page setup - restart required'
+        };
+      }
       
       // Set aggressive timeouts for problematic operations
       // Optimized timeouts for Puppeteer 23.x responsiveness
@@ -1572,6 +1588,22 @@ function setupFrameHandling(page, forceDebug) {
                   console.log(formatLogMessage('debug', `[evalOnDoc] Site-specific Fetch/XHR interception enabled for: ${currentUrl}`));
               }
           }
+          // Quick browser health check before script injection
+          let browserResponsive = false;
+          try {
+              await Promise.race([
+                  browserInstance.version(), // Quick responsiveness test
+                  new Promise((_, reject) => 
+                      setTimeout(() => reject(new Error('Browser health check timeout')), 5000)
+                  )
+              ]);
+              browserResponsive = true;
+          } catch (healthErr) {
+              console.warn(formatLogMessage('warn', `[evalOnDoc] Browser unresponsive for ${currentUrl}: ${healthErr.message} - skipping script injection`));
+              browserResponsive = false;
+          }
+          
+          if (browserResponsive) {
           try {
               await page.evaluateOnNewDocument(() => {
                   // Prevent infinite reload loops
@@ -1636,7 +1668,16 @@ function setupFrameHandling(page, forceDebug) {
                   };
               });
           } catch (evalErr) {
-              console.warn(formatLogMessage('warn', `[evalOnDoc] Failed to set up Fetch/XHR interception for ${currentUrl}: ${evalErr.message}`));
+                  if (evalErr.message.includes('timed out') || evalErr.message.includes('ProtocolError')) {
+                      console.warn(formatLogMessage('warn', `[evalOnDoc] Script injection protocol timeout for ${currentUrl} - continuing without XHR/Fetch interception`));
+                  } else {
+                      console.warn(formatLogMessage('warn', `[evalOnDoc] Failed to set up Fetch/XHR interception for ${currentUrl}: ${evalErr.message}`));
+                  }
+          }
+          } else {
+              if (forceDebug) {
+                  console.log(formatLogMessage('debug', `[evalOnDoc] Continuing ${currentUrl} without XHR/Fetch interception due to browser health`));
+              }
           }
       }
       // --- END: evaluateOnNewDocument for Fetch/XHR Interception ---
@@ -1683,7 +1724,34 @@ function setupFrameHandling(page, forceDebug) {
       }
       // --- End of Per-Page CDP Setup ---
 
-      await page.setRequestInterception(true);
+      // Protected request interception setup with timeout
+      try {
+        // Test if network operations are responsive before enabling request interception
+        await Promise.race([
+          page.setRequestInterception(true),
+          new Promise((_, reject) => 
+            setTimeout(() => reject(new Error('Network.enable timeout')), 10000)
+          )
+        ]);
+        
+        if (forceDebug) {
+          console.log(formatLogMessage('debug', `Request interception enabled successfully for ${currentUrl}`));
+        }
+      } catch (networkErr) {
+        if (networkErr.message.includes('timed out') || 
+            networkErr.message.includes('Network.enable') || 
+            networkErr.message.includes('timeout')) {
+          console.warn(formatLogMessage('warn', `Network setup failed for ${currentUrl}: ${networkErr.message} - triggering browser restart`));
+          return { 
+            url: currentUrl, 
+            rules: [], 
+            success: false, 
+            needsImmediateRestart: true,
+            error: 'Network.enable timeout - browser restart required'
+          };
+        }
+        throw networkErr; // Re-throw other errors
+      }
 	  
 	  // Set up frame handling to suppress invalid URL errors
       setupFrameHandling(page, forceDebug);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanboynz/network-scanner",
-  "version": "1.0.85",
+  "version": "1.0.87",
   "description": "A Puppeteer-based network scanner for analyzing web traffic, generating adblock filter rules, and identifying third-party requests. Features include fingerprint spoofing, Cloudflare bypass, content analysis with curl/grep, and multiple output formats.",
   "main": "nwss.js",
   "scripts": {