@fanboynz/network-scanner 1.0.35 → 1.0.37

package/lib/browserhealth.js

@@ -17,7 +17,8 @@ async function checkBrowserHealth(browserInstance, timeout = 5000) {
     pageCount: 0,
     error: null,
     responseTime: 0,
-    recommendations: []
+    recommendations: [],
+    criticalError: false
   };
 
   const startTime = Date.now();
@@ -27,6 +28,7 @@ async function checkBrowserHealth(browserInstance, timeout = 5000) {
     if (!browserInstance || browserInstance.process() === null) {
       healthResult.error = 'Browser process not running';
       healthResult.recommendations.push('Create new browser instance');
+      healthResult.criticalError = true;
       return healthResult;
     }
 
@@ -71,7 +73,12 @@ async function checkBrowserHealth(browserInstance, timeout = 5000) {
         try { await testPage.close(); } catch (e) { /* ignore */ }
       }
       healthResult.error = `Page creation/navigation failed: ${pageTestError.message}`;
-      healthResult.recommendations.push('Browser restart recommended');
+      if (isCriticalProtocolError(pageTestError)) {
+        healthResult.recommendations.push('Browser restart required - critical protocol error');
+        healthResult.criticalError = true;
+      } else {
+        healthResult.recommendations.push('Browser restart recommended');
+      }
       return healthResult;
     }
 
@@ -88,10 +95,14 @@ async function checkBrowserHealth(browserInstance, timeout = 5000) {
     healthResult.responseTime = Date.now() - startTime;
     
     // Categorize error types for better recommendations
-    if (error.message.includes('timeout') || error.message.includes('unresponsive')) {
+    if (error.message.includes('Runtime.callFunctionOn timed out') || 
+        error.message.includes('Protocol error') || 
+        error.message.includes('Target closed')) {
+      healthResult.recommendations.push('Browser restart required - critical protocol error');
+      healthResult.criticalError = true;
+    } else if (error.message.includes('timeout') || error.message.includes('unresponsive')) {
       healthResult.recommendations.push('Browser restart required - unresponsive');
-    } else if (error.message.includes('Protocol error') || error.message.includes('Target closed')) {
-      healthResult.recommendations.push('Browser restart required - protocol error');
+      healthResult.criticalError = true;
     } else {
       healthResult.recommendations.push('Browser restart recommended - unknown error');
     }
@@ -152,6 +163,27 @@ async function checkBrowserMemory(browserInstance) {
   return memoryResult;
 }
 
+ /**
+ * 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'
+  ];
+  
+  return criticalErrors.some(criticalError => 
+    error.message.includes(criticalError)
+  );
+}
+
 /**
  * Performs comprehensive browser health assessment
  * @param {import('puppeteer').Browser} browserInstance - Puppeteer browser instance
@@ -196,6 +228,9 @@ async function performHealthAssessment(browserInstance, options = {}) {
   if (!assessment.browser.healthy) {
     assessment.overall = 'unhealthy';
     assessment.needsRestart = true;
+  } else if (assessment.browser.criticalError) {
+    assessment.overall = 'critical';
+    assessment.needsRestart = true;
   } else if (assessment.recommendations.length > 0) {
     assessment.overall = 'degraded';
     assessment.needsRestart = assessment.recommendations.some(rec => 
@@ -252,7 +287,10 @@ async function monitorBrowserHealth(browserInstance, context = {}, options = {})
     result.assessment = assessment;
 
     // Decision logic for restart
-    if (assessment.needsRestart) {
+    if (assessment.browser.criticalError) {
+      result.shouldRestart = true;
+      result.reason = `Critical protocol error detected - immediate restart required`;
+    } else if (assessment.needsRestart) {
       result.shouldRestart = true;
       result.reason = `Browser health: ${assessment.overall} - ${assessment.recommendations[0] || 'restart needed'}`;
     } else if (urlsSinceCleanup >= cleanupInterval) {
@@ -304,5 +342,6 @@ module.exports = {
   checkBrowserMemory,
   performHealthAssessment,
   monitorBrowserHealth,
-  isBrowserHealthy
+  isBrowserHealthy,
+  isCriticalProtocolError
 };

package/lib/cloudflare.js

@@ -1,40 +1,96 @@
 /**
- * Cloudflare bypass and challenge handling module - Updated for 2025
+ * Cloudflare bypass and challenge handling module - Enhanced with timeout handling
  * Handles phishing warnings, Turnstile challenges, and modern Cloudflare protections
  */
 
 /**
- * Cross-version compatible timeout function for Puppeteer
- * @param {import('puppeteer').Page} page - Puppeteer page instance
- * @param {number} timeout - Timeout in milliseconds
- * @returns {Promise<void>}
+ * Cross-version compatible timeout function for Puppeteer with timeout protection
  */
 async function waitForTimeout(page, timeout) {
   try {
     // Try newer Puppeteer method first
     if (typeof page.waitForTimeout === 'function') {
-      await page.waitForTimeout(timeout);
+      await Promise.race([
+        page.waitForTimeout(timeout),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('waitForTimeout exceeded')), timeout + 5000))
+      ]);
     } else if (typeof page.waitFor === 'function') {
-      // Fallback to older Puppeteer method
-      await page.waitFor(timeout);
+      await Promise.race([
+        page.waitFor(timeout),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('waitFor exceeded')), timeout + 5000))
+      ]);
     } else {
-      // Ultimate fallback using setTimeout
       await new Promise(resolve => setTimeout(resolve, timeout));
     }
   } catch (error) {
     // If all else fails, use setTimeout
-    await new Promise(resolve => setTimeout(resolve, timeout));
+    await new Promise(resolve => setTimeout(resolve, Math.min(timeout, 5000)));
   }
 }
 
 /**
- * Analyzes the current page to detect Cloudflare challenges - Updated for 2025
- * @param {import('puppeteer').Page} page - Puppeteer page instance
- * @returns {Promise<object>} Challenge information object
+ * Safe page evaluation with timeout protection
+ */
+async function safePageEvaluate(page, func, timeout = 10000) {
+  try {
+    return await Promise.race([
+      page.evaluate(func),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('Page evaluation timeout')), timeout)
+      )
+    ]);
+  } catch (error) {
+    console.warn(`[cloudflare] Page evaluation failed: ${error.message}`);
+    return {
+      isChallengePresent: false,
+      isPhishingWarning: false,
+      isTurnstile: false,
+      isJSChallenge: false,
+      isChallengeCompleted: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Safe element clicking with timeout protection
+ */
+async function safeClick(page, selector, timeout = 5000) {
+  try {
+    return await Promise.race([
+      page.click(selector, { timeout: timeout }),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('Click timeout')), timeout + 1000)
+      )
+    ]);
+  } catch (error) {
+    throw new Error(`Click failed: ${error.message}`);
+  }
+}
+
+/**
+ * Safe navigation waiting with timeout protection
+ */
+async function safeWaitForNavigation(page, timeout = 15000) {
+  try {
+    return await Promise.race([
+      page.waitForNavigation({ waitUntil: 'domcontentloaded', timeout: timeout }),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('Navigation timeout')), timeout + 2000)
+      )
+    ]);
+  } catch (error) {
+    console.warn(`[cloudflare] Navigation wait failed: ${error.message}`);
+    // Don't throw - just continue
+  }
+}
+
+/**
+ * Analyzes the current page to detect Cloudflare challenges - Enhanced with timeout protection
  */
 async function analyzeCloudflareChallenge(page) {
   try {
-    return await page.evaluate(() => {
+    return await safePageEvaluate(page, () => {
       const title = document.title || '';
       const bodyText = document.body ? document.body.textContent : '';
       
@@ -50,7 +106,6 @@ async function analyzeCloudflareChallenge(page) {
       const hasTurnstileCheckbox = document.querySelector('input[type="checkbox"].ctp-checkbox') !== null ||
                                   document.querySelector('.ctp-checkbox') !== null;
       
-      // Legacy challenge detection (still used on some sites)
       const hasLegacyCheckbox = document.querySelector('input[type="checkbox"]#challenge-form') !== null ||
                                document.querySelector('input[type="checkbox"][name="cf_captcha_kind"]') !== null;
       
@@ -73,14 +128,11 @@ async function analyzeCloudflareChallenge(page) {
                                 title.includes('Attention Required') ||
                                 document.querySelector('a[href*="continue"]') !== null;
       
-      // Check for Turnstile response token
       const hasTurnstileResponse = document.querySelector('input[name="cf-turnstile-response"]') !== null;
       
-      // Check for challenge completion indicators
       const isChallengeCompleted = hasTurnstileResponse && 
                                   document.querySelector('input[name="cf-turnstile-response"]')?.value;
       
-      // Enhanced challenge detection logic
       const isChallengePresent = title.includes('Just a moment') ||
                                title.includes('Checking your browser') ||
                                bodyText.includes('Verify you are human') ||
@@ -107,9 +159,9 @@ async function analyzeCloudflareChallenge(page) {
         hasCaptcha,
         hasTurnstileResponse,
         url: window.location.href,
-        bodySnippet: bodyText.substring(0, 200) // First 200 chars for debugging
+        bodySnippet: bodyText.substring(0, 200)
       };
-    });
+    }, 10000); // 10 second timeout for page evaluation
   } catch (error) {
     return {
       isChallengePresent: false,
@@ -123,11 +175,7 @@ async function analyzeCloudflareChallenge(page) {
 }
 
 /**
- * Handles Cloudflare phishing warnings by clicking the continue button
- * @param {import('puppeteer').Page} page - Puppeteer page instance
- * @param {string} currentUrl - Current URL being processed
- * @param {boolean} forceDebug - Debug mode flag
- * @returns {Promise<object>} Result object with success status and details
+ * Handles Cloudflare phishing warnings with timeout protection
  */
 async function handlePhishingWarning(page, currentUrl, forceDebug = false) {
   const result = {
@@ -140,7 +188,7 @@ async function handlePhishingWarning(page, currentUrl, forceDebug = false) {
   try {
     if (forceDebug) console.log(`[debug][cloudflare] Checking for phishing warning on ${currentUrl}`);
     
-    // Wait a moment for the warning page to load
+    // Shorter wait with timeout protection
     await waitForTimeout(page, 2000);
 
     const challengeInfo = await analyzeCloudflareChallenge(page);
@@ -150,14 +198,13 @@ async function handlePhishingWarning(page, currentUrl, forceDebug = false) {
       result.details = challengeInfo;
       
       if (forceDebug) {
-        console.log(`[debug][cloudflare] Phishing warning detected on ${currentUrl}:`);
-        console.log(`[debug][cloudflare]   Page Title: "${challengeInfo.title}"`);
-        console.log(`[debug][cloudflare]   Current URL: ${challengeInfo.url}`);
+        console.log(`[debug][cloudflare] Phishing warning detected on ${currentUrl}`);
       }
 
       try {
-        await page.click('a[href*="continue"]', { timeout: 5000 });
-        await page.waitForNavigation({ waitUntil: 'load', timeout: 30000 });
+        // Use safe click with shorter timeout
+        await safeClick(page, 'a[href*="continue"]', 3000);
+        await safeWaitForNavigation(page, 10000);
         
         result.success = true;
         if (forceDebug) console.log(`[debug][cloudflare] Successfully bypassed phishing warning for ${currentUrl}`);
@@ -178,11 +225,7 @@ async function handlePhishingWarning(page, currentUrl, forceDebug = false) {
 }
 
 /**
- * Attempts to solve Cloudflare challenges including Turnstile - Updated for 2025
- * @param {import('puppeteer').Page} page - Puppeteer page instance
- * @param {string} currentUrl - Current URL being processed
- * @param {boolean} forceDebug - Debug mode flag
- * @returns {Promise<object>} Result object with success status and details
+ * Attempts to solve Cloudflare challenges with timeout protection
  */
 async function handleVerificationChallenge(page, currentUrl, forceDebug = false) {
   const result = {
@@ -196,8 +239,8 @@ async function handleVerificationChallenge(page, currentUrl, forceDebug = false)
   try {
     if (forceDebug) console.log(`[debug][cloudflare] Checking for verification challenge on ${currentUrl}`);
     
-    // Wait for potential Cloudflare challenge to appear
-    await waitForTimeout(page, 3000);
+    // Shorter wait for challenges
+    await waitForTimeout(page, 2000);
 
     const challengeInfo = await analyzeCloudflareChallenge(page);
     result.details = challengeInfo;
@@ -206,82 +249,70 @@ async function handleVerificationChallenge(page, currentUrl, forceDebug = false)
       result.attempted = true;
       
       if (forceDebug) {
-        console.log(`[debug][cloudflare] Challenge detected on ${currentUrl}:`);
-        console.log(`[debug][cloudflare]   Page Title: "${challengeInfo.title}"`);
-        console.log(`[debug][cloudflare]   Current URL: ${challengeInfo.url}`);
-        console.log(`[debug][cloudflare]   Is Turnstile: ${challengeInfo.isTurnstile}`);
-        console.log(`[debug][cloudflare]   Is JS Challenge: ${challengeInfo.isJSChallenge}`);
-        console.log(`[debug][cloudflare]   Has Legacy Checkbox: ${challengeInfo.hasLegacyCheckbox}`);
-        console.log(`[debug][cloudflare]   Has Turnstile Iframe: ${challengeInfo.hasTurnstileIframe}`);
-        console.log(`[debug][cloudflare]   Has Turnstile Container: ${challengeInfo.hasTurnstileContainer}`);
-        console.log(`[debug][cloudflare]   Has CAPTCHA: ${challengeInfo.hasCaptcha}`);
+        console.log(`[debug][cloudflare] Challenge detected on ${currentUrl}`);
       }
 
       // Check for CAPTCHA that requires human intervention
       if (challengeInfo.hasCaptcha) {
         result.requiresHuman = true;
         result.error = 'CAPTCHA detected - requires human intervention';
-        console.warn(`? [cloudflare] CAPTCHA detected on ${currentUrl} - requires human intervention`);
         if (forceDebug) console.log(`[debug][cloudflare] Skipping automatic bypass due to CAPTCHA requirement`);
         return result;
       }
 
-      // Attempt to solve the challenge with updated methods
-      const solveResult = await attemptChallengeSolve(page, currentUrl, challengeInfo, forceDebug);
+      // Attempt to solve the challenge with timeout protection
+      const solveResult = await attemptChallengeSolveWithTimeout(page, currentUrl, challengeInfo, forceDebug);
       result.success = solveResult.success;
       result.error = solveResult.error;
       
     } else {
       if (forceDebug) console.log(`[debug][cloudflare] No verification challenge detected on ${currentUrl}`);
-      result.success = true; // No challenge to handle
+      result.success = true;
     }
   } catch (error) {
     result.error = error.message;
-    if (forceDebug) {
-      console.log(`[debug][cloudflare] Challenge check failed for ${currentUrl}:`);
-      console.log(`[debug][cloudflare]   Error: ${error.message}`);
-      console.log(`[debug][cloudflare]   Stack: ${error.stack}`);
-    }
+    if (forceDebug) console.log(`[debug][cloudflare] Challenge check failed for ${currentUrl}: ${error.message}`);
   }
 
   return result;
 }
 
 /**
- * Attempts to solve a Cloudflare challenge with modern techniques - Updated for 2025
- * @param {import('puppeteer').Page} page - Puppeteer page instance
- * @param {string} currentUrl - Current URL being processed
- * @param {object} challengeInfo - Challenge analysis results
- * @param {boolean} forceDebug - Debug mode flag
- * @returns {Promise<object>} Solve attempt result
+ * Challenge solving with overall timeout protection
  */
-async function attemptChallengeSolve(page, currentUrl, challengeInfo, forceDebug = false) {
+async function attemptChallengeSolveWithTimeout(page, currentUrl, challengeInfo, forceDebug = false) {
   const result = {
     success: false,
     error: null,
     method: null
   };
 
-  // Method 1: Handle Turnstile challenges (2025 primary method)
-  if (challengeInfo.isTurnstile) {
-    try {
-      if (forceDebug) console.log(`[debug][cloudflare] Attempting Turnstile method for ${currentUrl}`);
-      
-      const turnstileResult = await handleTurnstileChallenge(page, forceDebug);
-      if (turnstileResult.success) {
-        result.success = true;
-        result.method = 'turnstile';
-        if (forceDebug) console.log(`[debug][cloudflare] Turnstile challenge solved successfully for ${currentUrl}`);
-        return result;
-      } else {
-        if (forceDebug) console.log(`[debug][cloudflare] Turnstile method failed: ${turnstileResult.error}`);
-      }
-    } catch (turnstileError) {
-      if (forceDebug) console.log(`[debug][cloudflare] Turnstile method error: ${turnstileError.message}`);
-    }
+  try {
+    // Overall timeout for all challenge solving attempts
+    return await Promise.race([
+      attemptChallengeSolve(page, currentUrl, challengeInfo, forceDebug),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('Challenge solving timeout')), 30000)
+      )
+    ]);
+  } catch (error) {
+    result.error = `Challenge solving timed out: ${error.message}`;
+    if (forceDebug) console.log(`[debug][cloudflare] Challenge solving timeout for ${currentUrl}`);
+    return result;
   }
+}
+
+/**
+ * Attempts to solve a Cloudflare challenge with modern techniques
+ */
+async function attemptChallengeSolve(page, currentUrl, challengeInfo, forceDebug = false) {
+  const result = {
+    success: false,
+    error: null,
+    method: null
+  };
 
-  // Method 2: Handle JS challenges (wait for automatic completion)
+  // Method 1: Handle JS challenges (wait for automatic completion) - Most reliable
   if (challengeInfo.isJSChallenge) {
     try {
       if (forceDebug) console.log(`[debug][cloudflare] Attempting JS challenge wait for ${currentUrl}`);
@@ -298,6 +329,23 @@ async function attemptChallengeSolve(page, currentUrl, challengeInfo, forceDebug
     }
   }
 
+  // Method 2: Handle Turnstile challenges (interactive)
+  if (challengeInfo.isTurnstile) {
+    try {
+      if (forceDebug) console.log(`[debug][cloudflare] Attempting Turnstile method for ${currentUrl}`);
+      
+      const turnstileResult = await handleTurnstileChallenge(page, forceDebug);
+      if (turnstileResult.success) {
+        result.success = true;
+        result.method = 'turnstile';
+        if (forceDebug) console.log(`[debug][cloudflare] Turnstile challenge solved successfully for ${currentUrl}`);
+        return result;
+      }
+    } catch (turnstileError) {
+      if (forceDebug) console.log(`[debug][cloudflare] Turnstile method error: ${turnstileError.message}`);
+    }
+  }
+
   // Method 3: Legacy checkbox interaction (fallback)
   if (challengeInfo.hasLegacyCheckbox) {
     try {
@@ -315,52 +363,51 @@ async function attemptChallengeSolve(page, currentUrl, challengeInfo, forceDebug
     }
   }
 
-  // Method 4: Alternative element clicking (final fallback)
+  if (!result.success) {
+    result.error = result.error || 'All challenge bypass methods failed';
+  }
+
+  return result;
+}
+
+/**
+ * Waits for JS challenge completion with timeout protection
+ */
+async function waitForJSChallengeCompletion(page, forceDebug = false) {
+  const result = {
+    success: false,
+    error: null
+  };
+
   try {
-    if (forceDebug) console.log(`[debug][cloudflare] Trying alternative click method for ${currentUrl}`);
+    if (forceDebug) console.log(`[debug][cloudflare] Waiting for JS challenge completion`);
     
-    const alternatives = [
-      '.cf-challenge-running',
-      '[data-ray]',
-      '.challenge-stage',
-      '.challenge-form'
-    ];
+    // Wait for challenge to complete automatically with shorter timeout
+    await Promise.race([
+      page.waitForFunction(
+        () => {
+          return !document.body.textContent.includes('Checking your browser') &&
+                 !document.body.textContent.includes('Please wait while we verify') &&
+                 !document.querySelector('.cf-challenge-running') &&
+                 !document.querySelector('[data-cf-challenge]');
+        },
+        { timeout: 20000 }
+      ),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('JS challenge timeout')), 25000)
+      )
+    ]);
     
-    for (const selector of alternatives) {
-      try {
-        await page.click(selector, { timeout: 3000 });
-        await waitForTimeout(page, 3000);
-        
-        // Check if challenge is solved
-        const completionCheck = await checkChallengeCompletion(page);
-        if (completionCheck.isCompleted) {
-          result.success = true;
-          result.method = 'alternative_click';
-          if (forceDebug) console.log(`[debug][cloudflare] Alternative click method succeeded for ${currentUrl} using ${selector}`);
-          return result;
-        }
-      } catch (clickError) {
-        // Continue to next selector
-        continue;
-      }
-    }
-  } catch (altError) {
-    result.error = `All bypass methods failed. Last error: ${altError.message}`;
-    if (forceDebug) console.log(`[debug][cloudflare] All bypass methods failed for ${currentUrl}: ${altError.message}`);
-  }
-
-  if (!result.success) {
-    result.error = result.error || 'All challenge bypass methods failed';
+    result.success = true;
+  } catch (error) {
+    result.error = `JS challenge timeout: ${error.message}`;
   }
 
   return result;
 }
 
 /**
- * Handles modern Turnstile challenges - New for 2025
- * @param {import('puppeteer').Page} page - Puppeteer page instance
- * @param {boolean} forceDebug - Debug mode flag
- * @returns {Promise<object>} Turnstile handling result
+ * Handles modern Turnstile challenges with timeout protection
  */
 async function handleTurnstileChallenge(page, forceDebug = false) {
   const result = {
@@ -369,7 +416,9 @@ async function handleTurnstileChallenge(page, forceDebug = false) {
   };
 
   try {
-    // Wait for Turnstile iframe to load
+    // Much shorter timeout for Turnstile operations
+    const turnstileTimeout = 10000; // 10 seconds
+    
     const turnstileSelectors = [
       'iframe[src*="challenges.cloudflare.com"]',
       'iframe[title*="Widget containing a Cloudflare"]',
@@ -379,7 +428,11 @@ async function handleTurnstileChallenge(page, forceDebug = false) {
     let turnstileFrame = null;
     for (const selector of turnstileSelectors) {
       try {
-        await page.waitForSelector(selector, { timeout: 5000 });
+        await Promise.race([
+          page.waitForSelector(selector, { timeout: 3000 }),
+          new Promise((_, reject) => setTimeout(() => reject(new Error('Selector timeout')), 4000))
+        ]);
+        
         const frames = await page.frames();
         turnstileFrame = frames.find(frame => 
           frame.url().includes('challenges.cloudflare.com') ||
@@ -394,7 +447,6 @@ async function handleTurnstileChallenge(page, forceDebug = false) {
     if (turnstileFrame) {
       if (forceDebug) console.log(`[debug][cloudflare] Found Turnstile iframe`);
       
-      // Wait for checkbox in iframe
       const checkboxSelectors = [
         'input[type="checkbox"].ctp-checkbox',
         'input[type="checkbox"]',
@@ -404,10 +456,12 @@ async function handleTurnstileChallenge(page, forceDebug = false) {
       
       for (const selector of checkboxSelectors) {
         try {
-          await turnstileFrame.waitForSelector(selector, { timeout: 5000 });
+          await Promise.race([
+            turnstileFrame.waitForSelector(selector, { timeout: 3000 }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Checkbox timeout')), 4000))
+          ]);
           
-          // Simulate human-like interaction
-          await waitForTimeout(page, Math.random() * 1000 + 500);
+          await waitForTimeout(page, 500);
           await turnstileFrame.click(selector);
           
           if (forceDebug) console.log(`[debug][cloudflare] Clicked Turnstile checkbox: ${selector}`);
@@ -417,48 +471,21 @@ async function handleTurnstileChallenge(page, forceDebug = false) {
         }
       }
       
-      // Wait for Turnstile completion
-      await page.waitForFunction(
-        () => {
-          const responseInput = document.querySelector('input[name="cf-turnstile-response"]');
-          return responseInput && responseInput.value && responseInput.value.length > 0;
-        },
-        { timeout: 30000 }
-      );
+      // Wait for Turnstile completion with timeout
+      await Promise.race([
+        page.waitForFunction(
+          () => {
+            const responseInput = document.querySelector('input[name="cf-turnstile-response"]');
+            return responseInput && responseInput.value && responseInput.value.length > 0;
+          },
+          { timeout: 15000 }
+        ),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Turnstile completion timeout')), 20000))
+      ]);
       
       result.success = true;
     } else {
-      // Try container-based Turnstile (non-iframe)
-      const containerSelectors = [
-        '.cf-turnstile',
-        '.ctp-checkbox-container',
-        '.ctp-checkbox-label'
-      ];
-      
-      for (const selector of containerSelectors) {
-        try {
-          await page.waitForSelector(selector, { timeout: 5000 });
-          
-          // Human-like interaction
-          await waitForTimeout(page, Math.random() * 1000 + 500);
-          await page.click(selector);
-          
-          if (forceDebug) console.log(`[debug][cloudflare] Clicked Turnstile container: ${selector}`);
-          
-          // Wait for completion
-          const completionCheck = await checkChallengeCompletion(page);
-          if (completionCheck.isCompleted) {
-            result.success = true;
-            break;
-          }
-        } catch (e) {
-          continue;
-        }
-      }
-      
-      if (!result.success) {
-        result.error = 'Turnstile iframe/container not found or not interactive';
-      }
+      result.error = 'Turnstile iframe not found';
     }
     
   } catch (error) {
@@ -469,44 +496,7 @@ async function handleTurnstileChallenge(page, forceDebug = false) {
 }
 
 /**
- * Waits for JS challenge completion - New for 2025
- * @param {import('puppeteer').Page} page - Puppeteer page instance
- * @param {boolean} forceDebug - Debug mode flag
- * @returns {Promise<object>} JS challenge result
- */
-async function waitForJSChallengeCompletion(page, forceDebug = false) {
-  const result = {
-    success: false,
-    error: null
-  };
-
-  try {
-    if (forceDebug) console.log(`[debug][cloudflare] Waiting for JS challenge completion`);
-    
-    // Wait for challenge to complete automatically
-    await page.waitForFunction(
-      () => {
-        return !document.body.textContent.includes('Checking your browser') &&
-               !document.body.textContent.includes('Please wait while we verify') &&
-               !document.querySelector('.cf-challenge-running') &&
-               !document.querySelector('[data-cf-challenge]');
-      },
-      { timeout: 30000 }
-    );
-    
-    result.success = true;
-  } catch (error) {
-    result.error = `JS challenge timeout: ${error.message}`;
-  }
-
-  return result;
-}
-
-/**
- * Handles legacy checkbox challenges - Fallback for older implementations
- * @param {import('puppeteer').Page} page - Puppeteer page instance
- * @param {boolean} forceDebug - Debug mode flag
- * @returns {Promise<object>} Legacy challenge result
+ * Handles legacy checkbox challenges with timeout protection
  */
 async function handleLegacyCheckbox(page, forceDebug = false) {
   const result = {
@@ -523,27 +513,20 @@ async function handleLegacyCheckbox(page, forceDebug = false) {
 
     for (const selector of legacySelectors) {
       try {
-        await page.waitForSelector(selector, { timeout: 5000 });
+        await Promise.race([
+          page.waitForSelector(selector, { timeout: 3000 }),
+          new Promise((_, reject) => setTimeout(() => reject(new Error('Legacy selector timeout')), 4000))
+        ]);
         
         const checkbox = await page.$(selector);
         if (checkbox) {
-          const box = await checkbox.boundingBox();
-          if (box) {
-            // Simulate human-like mouse movement
-            await page.mouse.move(box.x - 50, box.y - 50);
-            await waitForTimeout(page, Math.random() * 500 + 200);
-            await page.mouse.move(box.x + box.width/2, box.y + box.height/2, { steps: 5 });
-            await waitForTimeout(page, Math.random() * 300 + 100);
-
-            await checkbox.click();
-            if (forceDebug) console.log(`[debug][cloudflare] Clicked legacy checkbox: ${selector}`);
-
-            // Wait for challenge completion
-            const completionCheck = await checkChallengeCompletion(page);
-            if (completionCheck.isCompleted) {
-              result.success = true;
-              break;
-            }
+          await checkbox.click();
+          if (forceDebug) console.log(`[debug][cloudflare] Clicked legacy checkbox: ${selector}`);
+
+          const completionCheck = await checkChallengeCompletion(page);
+          if (completionCheck.isCompleted) {
+            result.success = true;
+            break;
           }
         }
       } catch (e) {
@@ -563,28 +546,24 @@ async function handleLegacyCheckbox(page, forceDebug = false) {
 }
 
 /**
- * Checks if challenge has been completed - New utility function
- * @param {import('puppeteer').Page} page - Puppeteer page instance
- * @returns {Promise<object>} Completion status
+ * Checks if challenge has been completed with timeout protection
  */
 async function checkChallengeCompletion(page) {
   try {
-    const isCompleted = await page.evaluate(() => {
-      // Check for absence of challenge indicators
+    const isCompleted = await safePageEvaluate(page, () => {
       const noChallengeRunning = !document.querySelector('.cf-challenge-running');
       const noChallengeContainer = !document.querySelector('.cf-challenge-container');
       const noChallengePage = !document.body.textContent.includes('Checking your browser') &&
                              !document.body.textContent.includes('Just a moment') &&
                              !document.body.textContent.includes('Verify you are human');
       
-      // Check for completion indicators
       const hasClearanceCookie = document.cookie.includes('cf_clearance');
       const hasTurnstileResponse = document.querySelector('input[name="cf-turnstile-response"]')?.value;
       
       return (noChallengeRunning && noChallengeContainer && noChallengePage) ||
              hasClearanceCookie ||
              hasTurnstileResponse;
-    });
+    }, 5000);
     
     return { isCompleted };
   } catch (error) {
@@ -593,12 +572,7 @@ async function checkChallengeCompletion(page) {
 }
 
 /**
- * Main function to handle all Cloudflare challenges for a given page - Updated for 2025
- * @param {import('puppeteer').Page} page - Puppeteer page instance
- * @param {string} currentUrl - Current URL being processed
- * @param {object} siteConfig - Site configuration object
- * @param {boolean} forceDebug - Debug mode flag
- * @returns {Promise<object>} Combined result of all Cloudflare handling
+ * Main function to handle all Cloudflare challenges with comprehensive timeout protection
  */
 async function handleCloudflareProtection(page, currentUrl, siteConfig, forceDebug = false) {
   const result = {
@@ -608,6 +582,40 @@ async function handleCloudflareProtection(page, currentUrl, siteConfig, forceDeb
     errors: []
   };
 
+  try {
+    // Overall timeout for all Cloudflare operations
+    return await Promise.race([
+      performCloudflareHandling(page, currentUrl, siteConfig, forceDebug),
+      new Promise((resolve) => {
+        setTimeout(() => {
+          console.warn(`[cloudflare] Overall timeout for ${currentUrl} - continuing with scan`);
+          resolve({
+            phishingWarning: { attempted: false, success: true },
+            verificationChallenge: { attempted: false, success: true },
+            overallSuccess: true,
+            errors: ['Cloudflare handling timed out']
+          });
+        }, 45000); // 45 second overall timeout
+      })
+    ]);
+  } catch (error) {
+    result.overallSuccess = false;
+    result.errors.push(`Cloudflare handling failed: ${error.message}`);
+    return result;
+  }
+}
+
+/**
+ * Performs the actual Cloudflare handling
+ */
+async function performCloudflareHandling(page, currentUrl, siteConfig, forceDebug = false) {
+  const result = {
+    phishingWarning: { attempted: false, success: false },
+    verificationChallenge: { attempted: false, success: false },
+    overallSuccess: true,
+    errors: []
+  };
+
   // Handle phishing warnings if enabled
   if (siteConfig.cloudflare_phish === true) {
     const phishingResult = await handlePhishingWarning(page, currentUrl, forceDebug);
@@ -634,7 +642,6 @@ async function handleCloudflareProtection(page, currentUrl, siteConfig, forceDeb
     }
   }
 
-  // Log overall result
   if (!result.overallSuccess && forceDebug) {
     console.log(`[debug][cloudflare] Overall Cloudflare handling failed for ${currentUrl}:`);
     result.errors.forEach(error => {
@@ -657,4 +664,4 @@ module.exports = {
   waitForJSChallengeCompletion,
   handleLegacyCheckbox,
   checkChallengeCompletion
-};
+};

package/nwss.js

@@ -1,4 +1,4 @@
-// === Network scanner script (nwss.js) v1.0.35 ===
+// === Network scanner script (nwss.js) v1.0.37 ===
 
 // puppeteer for browser automation, fs for file system operations, psl for domain parsing.
 // const pLimit = require('p-limit'); // Will be dynamically imported
@@ -33,7 +33,7 @@ const { navigateWithRedirectHandling, handleRedirectTimeout } = require('./lib/r
 const { monitorBrowserHealth, isBrowserHealthy } = require('./lib/browserhealth');
 
 // --- Script Configuration & Constants ---
-const VERSION = '1.0.35'; // Script version
+const VERSION = '1.0.37'; // Script version
 const MAX_CONCURRENT_SITES = 5;
 const RESOURCE_CLEANUP_INTERVAL = 80; // Close browser and restart every N sites to free resources
 
@@ -936,7 +936,7 @@ function setupFrameHandling(page, forceDebug) {
 	    '--disable-image-animation-resync'
         ],
         headless: launchHeadless ? 'shell' : false,
-        protocolTimeout: 500000
+        protocolTimeout: 60000  // 60 seconds
     });
     
     // Store the user data directory on the browser object for cleanup
@@ -2091,7 +2091,21 @@ function setupFrameHandling(page, forceDebug) {
       }
       
     } catch (err) {
-      // Enhanced error handling with rule preservation for partial matches
+    // Enhanced error handling with rule preservation for partial matches
+    if (err.message.includes('Runtime.callFunctionOn timed out') || 
+        err.message.includes('Protocol error') ||
+        err.message.includes('Target closed') ||
+        err.message.includes('Browser has been closed')) {
+      console.error(formatLogMessage('error', `Critical browser protocol error on ${currentUrl}: ${err.message}`));
+      return { 
+        url: currentUrl, 
+        rules: [], 
+        success: false, 
+        needsImmediateRestart: true,
+        error: `Critical protocol error: ${err.message}`
+      };
+    }
+    
       if (err.message.includes('Protocol error') || 
           err.message.includes('Target closed') ||
           err.message.includes('Browser process was killed') ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanboynz/network-scanner",
-  "version": "1.0.35",
+  "version": "1.0.37",
   "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": {