@fanboynz/network-scanner 2.0.63 → 2.0.65

package/nwss.js

@@ -58,7 +58,8 @@ const { clearSiteData } = require('./lib/clear_sitedata');
 // Referrer header generation
 const { getReferrerForUrl, validateReferrerConfig, validateReferrerDisable } = require('./lib/referrer');
 // Adblock rules parser
-const { parseAdblockRules } = require('./lib/adblock');
+const adblockJs = require('./lib/adblock');
+const adblockRust = require('./lib/adblock-rust');
 // WireGuard VPN
 const { connectForSite: wgConnect, disconnectForSite: wgDisconnect, disconnectAll: wgDisconnectAll, validateVpnConfig, normalizeVpnConfig } = require('./lib/wireguard_vpn');
 // OpenVPN
@@ -359,6 +360,12 @@ let adblockEnabled = false;
 let adblockMatcher = null;
 let adblockStats = { blocked: 0, allowed: 0 };
 
+// Cloudflare scan-wide stats. errorPages counts URLs where the returned page
+// was a Cloudflare-served 5xx origin error (522/523/etc.) — no bypass
+// possible, useful signal for diagnosing dead-origin scans. Named distinct
+// from the local cloudflareStats = getCacheStats() in the debug stats block.
+let cloudflareScanStats = { errorPages: 0 };
+
 // Validate --adblock-rules usage - ignore if used incorrectly instead of erroring
 if (adblockRulesMode) {
   if (!outputFile) {
@@ -477,78 +484,10 @@ if (testValidation) {
   }
 }
 
-if (validateConfig) {
-  console.log(`\n${messageColors.processing('Validating configuration file...')}`);
-  try {
-    const validation = validateFullConfig(config, { forceDebug, silentMode });
-    
-    // Validate referrer_headers format
-    for (const site of sites) {
-       if (site.referrer_headers && typeof site.referrer_headers === 'object' && !Array.isArray(site.referrer_headers)) {
-         const validation = validateReferrerConfig(site.referrer_headers);
-         if (!validation.isValid) {
-           console.warn(`⚠ Invalid referrer_headers configuration: ${validation.errors.join(', ')}`);
-         }
-         if (validation.warnings.length > 0) {
-           console.warn(`⚠ Referrer warnings: ${validation.warnings.join(', ')}`);
-         }
-       }
-       // Validate referrer_disable format
-       if (site.referrer_disable) {
-         const disableValidation = validateReferrerDisable(site.referrer_disable);
-         if (!disableValidation.isValid) {
-           console.warn(`⚠ Invalid referrer_disable configuration: ${disableValidation.errors.join(', ')}`);
-         }
-         if (disableValidation.warnings.length > 0) {
-           console.warn(`⚠ Referrer disable warnings: ${disableValidation.warnings.join(', ')}`);
-         }
-       }
-    }
-
-    // Validate VPN configurations
-    for (const site of sites) {
-      if (site.vpn) {
-        const vpnNorm = normalizeVpnConfig(site.vpn);
-        const vpnValidation = validateVpnConfig(vpnNorm);
-        if (!vpnValidation.isValid) {
-          console.warn(`⚠ Invalid vpn configuration for ${site.url}: ${vpnValidation.errors.join(', ')}`);
-        }
-        if (vpnValidation.warnings.length > 0) {
-          vpnValidation.warnings.forEach(w => console.warn(`⚠ VPN warning for ${site.url}: ${w}`));
-        }
-      }
-      if (site.openvpn) {
-        const ovpnNorm = normalizeOvpnConfig(site.openvpn);
-        const ovpnValidation = validateOvpnConfig(ovpnNorm);
-        if (!ovpnValidation.isValid) {
-          console.warn(`⚠ Invalid openvpn configuration for ${site.url}: ${ovpnValidation.errors.join(', ')}`);
-        }
-        if (ovpnValidation.warnings.length > 0) {
-          ovpnValidation.warnings.forEach(w => console.warn(`⚠ OpenVPN warning for ${site.url}: ${w}`));
-        }
-      }
-      if (site.vpn && site.openvpn) {
-        console.warn(`⚠ ${site.url} has both vpn and openvpn configured — only one will be used (vpn takes precedence)`);
-      }
-    }
-
-    if (validation.isValid) {
-      console.log(`${messageColors.success('✅ Configuration is valid!')}`);
-      console.log(`${messageColors.info('Summary:')} ${validation.summary.validSites}/${validation.summary.totalSites} sites valid`);
-      if (validation.summary.sitesWithWarnings > 0) {
-        console.log(`${messageColors.warn('⚠ Warnings:')} ${validation.summary.sitesWithWarnings} sites have warnings`);
-      }
-      process.exit(0);
-    } else {
-      console.log(`${messageColors.error('❌ Configuration validation failed!')}`);
-      console.log(`${messageColors.error('Errors:')} ${validation.globalErrors.length} global, ${validation.summary.sitesWithErrors} site-specific`);
-      process.exit(1);
-    }
-  } catch (validationErr) {
-    console.error(`❌ Validation failed: ${validationErr.message}`);
-    process.exit(1);
-  }
-}
+// Note: --validate-config is handled further down, AFTER the config file is
+// loaded and `config`/`sites` are populated. Running it here would fail with
+// "Cannot access 'config' before initialization" since those are declared
+// later in the module.
 
 if (validateRules || validateRulesFile) {
   const filesToValidate = validateRulesFile ? [validateRulesFile] : [outputFile, compareFile].filter(Boolean);
@@ -594,6 +533,22 @@ if (validateRules || validateRulesFile) {
   }
 }
 
+// Parse --adblock-engine=<js|rust> (default: js). Selects the matcher backend
+// used by --block-ads. The rust engine requires the optional adblock-rs package.
+const adblockEngineIndex = args.findIndex(arg => arg.startsWith('--adblock-engine'));
+let adblockEngineName = 'js';
+if (adblockEngineIndex !== -1) {
+  const engineArg = args[adblockEngineIndex].includes('=')
+    ? args[adblockEngineIndex].split('=')[1]
+    : args[adblockEngineIndex + 1];
+  if (engineArg === 'rust' || engineArg === 'js') {
+    adblockEngineName = engineArg;
+  } else {
+    console.log(`Error: --adblock-engine must be 'js' or 'rust' (got: ${engineArg})`);
+    process.exit(1);
+  }
+}
+
 // Parse --block-ads argument for request-level ad blocking (supports comma-separated lists)
 const blockAdsIndex = args.findIndex(arg => arg.startsWith('--block-ads'));
 if (blockAdsIndex !== -1) {
@@ -614,18 +569,31 @@ if (blockAdsIndex !== -1) {
     }
   }
 
-  // Concatenate multiple lists into a single temp file for the parser
-  let rulesFile = rulesFiles[0];
-  if (rulesFiles.length > 1) {
-    rulesFile = path.join(os.tmpdir(), `nwss-adblock-combined-${Date.now()}.txt`);
-    const combined = rulesFiles.map(f => fs.readFileSync(f, 'utf-8')).join('\n');
-    fs.writeFileSync(rulesFile, combined);
-  }
-
   adblockEnabled = true;
-  adblockMatcher = parseAdblockRules(rulesFile, { enableLogging: forceDebug });
+  const engine = adblockEngineName === 'rust' ? adblockRust : adblockJs;
+  try {
+    if (engine === adblockRust) {
+      // Rust wrapper accepts an array directly — no temp file needed.
+      adblockMatcher = engine.parseAdblockRules(rulesFiles, { enableLogging: forceDebug });
+    } else {
+      // JS engine takes a single path; concat to a temp file when multiple lists.
+      let rulesFile = rulesFiles[0];
+      if (rulesFiles.length > 1) {
+        rulesFile = path.join(os.tmpdir(), `nwss-adblock-combined-${Date.now()}.txt`);
+        const combined = rulesFiles.map(f => fs.readFileSync(f, 'utf-8')).join('\n');
+        fs.writeFileSync(rulesFile, combined);
+      }
+      adblockMatcher = engine.parseAdblockRules(rulesFile, { enableLogging: forceDebug });
+    }
+  } catch (err) {
+    console.log(`Error: Failed to load adblock engine '${adblockEngineName}': ${err.message}`);
+    process.exit(1);
+  }
   const stats = adblockMatcher.getStats();
-  if (!silentMode) console.log(messageColors.success(`Adblock enabled: Loaded ${stats.total} blocking rules from ${rulesFiles.length} list${rulesFiles.length > 1 ? 's' : ''}`));
+  const ruleDesc = stats.total != null
+    ? `${stats.total} blocking rules`
+    : `compiled engine (cached)`;
+  if (!silentMode) console.log(messageColors.success(`Adblock enabled (${adblockEngineName}): Loaded ${ruleDesc} from ${rulesFiles.length} list${rulesFiles.length > 1 ? 's' : ''}`));
 }
 
 if (args.includes('--help') || args.includes('-h')) {
@@ -651,6 +619,9 @@ Output Format Options:
 Request Blocking:
   --block-ads=<file>             Block ads/trackers using EasyList format rules (||domain.com^, /ads/*, etc)
                                  Works at request-level for maximum performance
+                                 Supports comma-separated lists: --block-ads=easylist.txt,easyprivacy.txt
+  --adblock-engine=<js|rust>     Matcher backend for --block-ads (default: js)
+                                 'rust' uses Brave's adblock-rs (faster on large lists; needs: npm i adblock-rs)
 
 Per-config settings file (.nwssconfig):
   Place a .nwssconfig file in the project root to define per-config settings.
@@ -876,10 +847,86 @@ const {
   disable_ad_tagging = true,
   max_concurrent_sites = 6,
   resource_cleanup_interval = 80,
-  comments: globalComments, 
-  ...otherGlobalConfig 
+  comments: globalComments,
+  ...otherGlobalConfig
 } = config;
 
+// --validate-config runs here, after `config` and `sites` are populated.
+// Previously this block lived above the config load and triggered a TDZ
+// "Cannot access 'config' before initialization" error.
+if (validateConfig) {
+  console.log(`\n${messageColors.processing('Validating configuration file...')}`);
+  try {
+    const validation = validateFullConfig(config, { forceDebug, silentMode });
+
+    // Validate referrer_headers format
+    for (const site of sites) {
+       if (site.referrer_headers && typeof site.referrer_headers === 'object' && !Array.isArray(site.referrer_headers)) {
+         const refValidation = validateReferrerConfig(site.referrer_headers);
+         if (!refValidation.isValid) {
+           console.warn(`⚠ Invalid referrer_headers configuration: ${refValidation.errors.join(', ')}`);
+         }
+         if (refValidation.warnings.length > 0) {
+           console.warn(`⚠ Referrer warnings: ${refValidation.warnings.join(', ')}`);
+         }
+       }
+       // Validate referrer_disable format
+       if (site.referrer_disable) {
+         const disableValidation = validateReferrerDisable(site.referrer_disable);
+         if (!disableValidation.isValid) {
+           console.warn(`⚠ Invalid referrer_disable configuration: ${disableValidation.errors.join(', ')}`);
+         }
+         if (disableValidation.warnings.length > 0) {
+           console.warn(`⚠ Referrer disable warnings: ${disableValidation.warnings.join(', ')}`);
+         }
+       }
+    }
+
+    // Validate VPN configurations
+    for (const site of sites) {
+      if (site.vpn) {
+        const vpnNorm = normalizeVpnConfig(site.vpn);
+        const vpnValidation = validateVpnConfig(vpnNorm);
+        if (!vpnValidation.isValid) {
+          console.warn(`⚠ Invalid vpn configuration for ${site.url}: ${vpnValidation.errors.join(', ')}`);
+        }
+        if (vpnValidation.warnings.length > 0) {
+          vpnValidation.warnings.forEach(w => console.warn(`⚠ VPN warning for ${site.url}: ${w}`));
+        }
+      }
+      if (site.openvpn) {
+        const ovpnNorm = normalizeOvpnConfig(site.openvpn);
+        const ovpnValidation = validateOvpnConfig(ovpnNorm);
+        if (!ovpnValidation.isValid) {
+          console.warn(`⚠ Invalid openvpn configuration for ${site.url}: ${ovpnValidation.errors.join(', ')}`);
+        }
+        if (ovpnValidation.warnings.length > 0) {
+          ovpnValidation.warnings.forEach(w => console.warn(`⚠ OpenVPN warning for ${site.url}: ${w}`));
+        }
+      }
+      if (site.vpn && site.openvpn) {
+        console.warn(`⚠ ${site.url} has both vpn and openvpn configured — only one will be used (vpn takes precedence)`);
+      }
+    }
+
+    if (validation.isValid) {
+      console.log(`${messageColors.success('✅ Configuration is valid!')}`);
+      console.log(`${messageColors.info('Summary:')} ${validation.summary.validSites}/${validation.summary.totalSites} sites valid`);
+      if (validation.summary.sitesWithWarnings > 0) {
+        console.log(`${messageColors.warn('⚠ Warnings:')} ${validation.summary.sitesWithWarnings} sites have warnings`);
+      }
+      process.exit(0);
+    } else {
+      console.log(`${messageColors.error('❌ Configuration validation failed!')}`);
+      console.log(`${messageColors.error('Errors:')} ${validation.globalErrors.length} global, ${validation.summary.sitesWithErrors} site-specific`);
+      process.exit(1);
+    }
+  } catch (validationErr) {
+    console.error(`❌ Validation failed: ${validationErr.message}`);
+    process.exit(1);
+  }
+}
+
 // Pre-compile global blocked regexes ONCE (used in every processUrl call)
 const globalBlockedRegexes = Array.isArray(globalBlocked)
   ? globalBlocked.map(pattern => new RegExp(pattern))
@@ -3392,7 +3439,7 @@ function setupFrameHandling(page, forceDebug) {
           }
         }
         
-        const { finalUrl, redirected, redirectChain, originalUrl, redirectDomains } = navigationResult;
+        const { finalUrl, redirected, redirectChain, originalUrl, redirectDomains, httpStatus, cfRay } = navigationResult;
         
         // Check for same-page reload loops BEFORE redirect processing
         const loadCount = pageLoadHistory.get(currentUrl) || 0;
@@ -3501,8 +3548,14 @@ function setupFrameHandling(page, forceDebug) {
           }
         }
 
-        // Handle all Cloudflare protections using the enhanced module
-        const cloudflareResult = await handleCloudflareProtection(page, currentUrl, siteConfig, forceDebug);
+        // Handle all Cloudflare protections using the enhanced module. Pass
+        // httpStatus and cfRay captured at goto time so the outcome log can
+        // surface them — Puppeteer's response object is only available
+        // immediately after page.goto, so handleCloudflareProtection can't
+        // recover them from `page` alone.
+        const cloudflareResult = await handleCloudflareProtection(page, currentUrl, siteConfig, forceDebug, { httpStatus, cfRay });
+
+        if (cloudflareResult.cloudflareErrorPage) cloudflareScanStats.errorPages++;
 
         // Check if Cloudflare handling exceeded max retries and should terminate processing
         if (!cloudflareResult.overallSuccess && 
@@ -3535,7 +3588,10 @@ function setupFrameHandling(page, forceDebug) {
             console.warn(`   - ${error}`);
           });
           // Continue with scan despite Cloudflare issues
-        } else if (cloudflareResult.verificationChallenge?.success && forceDebug) {
+        } else if (cloudflareResult.verificationChallenge?.attempted && cloudflareResult.verificationChallenge?.success && forceDebug) {
+          // Require attempted === true so we don't log "Challenge solved using:
+          // undefined" for pages that had no challenge to solve (success: true
+          // is the natural state for that case).
           console.log(formatLogMessage('debug', `[cloudflare] Challenge solved using: ${cloudflareResult.verificationChallenge.method}`));
         }
 
@@ -4266,27 +4322,39 @@ function setupFrameHandling(page, forceDebug) {
  let forceRestartFlag = false; // Flag to trigger restart on next iteration
  
  const hangDetectionInterval = setInterval(() => {
+   // Progress check, counter, and forceRestartFlag MUST run regardless of
+   // debug mode — previously the entire body was gated on forceDebug, which
+   // made hang recovery a debug-only feature even though the restart
+   // machinery exists for production scans. Only the verbose diagnostic
+   // logs stay debug-gated; the "no progress" warning and the
+   // "triggering restart" error are user-visible recovery events.
+   if (processedUrlCount === lastProcessedCount) {
+     hangCheckCount++;
+     if (forceDebug) {
+       console.log(formatLogMessage('warn', `[HANG CHECK] No progress for ${hangCheckCount * 30}s`));
+     }
+     if (hangCheckCount >= 5) {
+       console.log(formatLogMessage('error', `[HANG CHECK] Hung for 2.5 minutes. Triggering emergency browser restart.`));
+       forceRestartFlag = true; // Set flag instead of exiting
+       hangCheckCount = 0; // Reset counter for next cycle
+     }
+   } else {
+     hangCheckCount = 0;
+   }
+   lastProcessedCount = processedUrlCount;
+
+   // Debug-only diagnostic snapshot
    if (forceDebug) {
      const currentBatch = Math.floor(currentBatchInfo.batchStart / RESOURCE_CLEANUP_INTERVAL) + 1;
      const totalBatches = Math.ceil(totalUrls / RESOURCE_CLEANUP_INTERVAL);
      console.log(formatLogMessage('debug', `[HANG CHECK] Processed: ${processedUrlCount}/${totalUrls} URLs, Batch: ${currentBatch}/${totalBatches}, Current batch size: ${currentBatchInfo.batchSize}`));
      console.log(formatLogMessage('debug', `[HANG CHECK] URLs since cleanup: ${urlsSinceLastCleanup}, Recent failures: ${results.slice(-3).filter(r => !r.success).length}/3`));
-     
-     // Check progress and trigger browser restart if hung
-     if (processedUrlCount === lastProcessedCount) {
-       hangCheckCount++;
-       console.log(formatLogMessage('warn', `[HANG CHECK] No progress for ${hangCheckCount * 30}s`));
-       if (hangCheckCount >= 5) {
-         console.log(formatLogMessage('error', `[HANG CHECK] Hung for 2.5 minutes. Triggering emergency browser restart.`));
-         forceRestartFlag = true; // Set flag instead of exiting
-         hangCheckCount = 0; // Reset counter for next cycle
-       }
-     } else {
-       hangCheckCount = 0;
-     }
-     lastProcessedCount = processedUrlCount;
    }
  }, 30000);
+ // Don't keep the event loop alive solely for the hang-check interval — the
+ // clearInterval calls at the normal-exit and error paths already cover the
+ // cleanup, this is belt-and-suspenders in case a future refactor moves them.
+ hangDetectionInterval.unref();
 
  // Process URLs in batches with exception handling
  let siteGroupIndex = 0;
@@ -4354,8 +4422,14 @@ function setupFrameHandling(page, forceDebug) {
       !healthCheck.reason?.includes('Scheduled cleanup') && 
       (healthCheck.reason?.includes('Critical') || healthCheck.reason?.includes('disconnected'));
     
-    // Restart browser if we've processed enough URLs, health check suggests it, hang detected, and this isn't the last site
-    if ((wouldExceedLimit || shouldRestartFromHealth || forceRestartFlag || (hasHighFailureRate && recentResults.length >= 6)) && urlsSinceLastCleanup > 8 && isNotLastBatch) {      
+    // Restart conditions split into hang recovery vs proactive triggers.
+    // Hang recovery (forceRestartFlag set by 2.5-min HANG CHECK or a per-URL
+    // timeout) bypasses the urlsSinceLastCleanup > 8 gate — a confirmed hang
+    // needs immediate restart even if we just cleaned up. Proactive triggers
+    // keep the gate to prevent thrashing.
+    const hangRecoveryRestart = forceRestartFlag;
+    const proactiveRestart = (wouldExceedLimit || shouldRestartFromHealth || (hasHighFailureRate && recentResults.length >= 6)) && urlsSinceLastCleanup > 8;
+    if ((hangRecoveryRestart || proactiveRestart) && isNotLastBatch) {
       let restartReason = 'Unknown';
       if (forceRestartFlag) {
         restartReason = 'Emergency restart due to 2.5-minute hang detection';
@@ -4484,16 +4558,58 @@ function setupFrameHandling(page, forceDebug) {
       console.log(formatLogMessage('debug', `[CONCURRENCY] Starting ${batchSize} concurrent tasks with limit ${MAX_CONCURRENT_SITES}`));
     }
     
- // Create tasks with timeout protection — skip domains that repeatedly timed out
- const batchTasks = currentBatch.map(task => originalLimit(() => {
+ // Create tasks with timeout protection — skip domains that repeatedly timed out.
+ // Wrapped in an outer try/finally so processedUrlCount is incremented exactly
+ // once per URL no matter which return/throw path is taken — that turns HANG
+ // CHECK's signal from "did the batch finish?" into "did any URL finish?",
+ // which is what 30-second tick granularity actually needs.
+ const batchTasks = currentBatch.map(task => originalLimit(async () => {
    try {
-     const taskDomain = new URL(task.url).hostname;
-     if ((domainTimeoutCounts.get(taskDomain) || 0) >= DOMAIN_TIMEOUT_THRESHOLD) {
-       if (!silentMode) console.log(formatLogMessage('info', `Skipping ${task.url} — ${taskDomain} timed out ${DOMAIN_TIMEOUT_THRESHOLD} times`));
-       return { url: task.url, rules: [], success: false, error: 'Domain repeatedly timed out', skipped: true };
+     // Short-circuit queued URLs once any URL in this batch has triggered a
+     // restart. Without this, the 80-URL batch in the user's hang trace
+     // would have to fail one-by-one at 120s each (~28 min total) before
+     // the boundary restart could fire. Now: first hang fires the flag,
+     // remaining queued URLs return immediately, batch completes, restart.
+     if (forceRestartFlag) {
+       return { url: task.url, rules: [], success: false, error: 'Browser restart pending', skipped: true };
+     }
+
+     try {
+       const taskDomain = new URL(task.url).hostname;
+       if ((domainTimeoutCounts.get(taskDomain) || 0) >= DOMAIN_TIMEOUT_THRESHOLD) {
+         if (!silentMode) console.log(formatLogMessage('info', `Skipping ${task.url} — ${taskDomain} timed out ${DOMAIN_TIMEOUT_THRESHOLD} times`));
+         return { url: task.url, rules: [], success: false, error: 'Domain repeatedly timed out', skipped: true };
+       }
+     } catch {}
+
+     // Per-URL timeout so a single hung processUrl can't block the batch
+     // forever. 120s is well past any legitimate slow page: Cloudflare
+     // adaptive max ~25s, nettools overall ~65s, navigation 15s.
+     const processUrlPromise = processUrl(task.url, task.config, browser);
+     let perUrlTimer;
+     try {
+       return await Promise.race([
+         processUrlPromise,
+         new Promise((_, reject) => {
+           perUrlTimer = setTimeout(() => reject(new Error('Per-URL timeout (120s)')), 120000);
+         })
+       ]);
+     } catch (err) {
+       if (err && err.message === 'Per-URL timeout (120s)') {
+         processUrlPromise.catch(() => {});
+         forceRestartFlag = true;
+         return { url: task.url, rules: [], success: false, error: 'Per-URL timeout (120s)', needsImmediateRestart: true };
+       }
+       throw err;
+     } finally {
+       if (perUrlTimer) clearTimeout(perUrlTimer);
      }
-   } catch {}
-   return processUrl(task.url, task.config, browser);
+   } finally {
+     // Always count completion — even on unexpected throw — so HANG CHECK's
+     // per-tick progress signal stays accurate. Replaces the old
+     // `processedUrlCount += batchSize` that ran after the whole batch.
+     processedUrlCount++;
+   }
  }));
  
  let batchResults;
@@ -4595,7 +4711,8 @@ function setupFrameHandling(page, forceDebug) {
       }
     }
     
-    processedUrlCount += batchSize;
+    // processedUrlCount is now incremented per-URL inside the batchTasks
+    // wrapper above; no batch-level += batchSize here.
     urlsSinceLastCleanup += batchSize;
 
     // Force browser restart if any URL had critical errors
@@ -4776,12 +4893,40 @@ function setupFrameHandling(page, forceDebug) {
        console.log(formatLogMessage('debug', `Cache hit rate: ${cloudflareStats.hitRate}, Total hits: ${cloudflareStats.hits}, Misses: ${cloudflareStats.misses}`));
        console.log(formatLogMessage('debug', `Cached detections: ${cloudflareStats.size}`));
      }
+     if (cloudflareScanStats.errorPages > 0) {
+       console.log(formatLogMessage('debug', `Cloudflare 5xx origin-error pages: ${cloudflareScanStats.errorPages} (no bypass possible — origin unreachable)`));
+     }
      // Log smart cache statistics (if cache is enabled)
      // Adblock statistics
      if (adblockEnabled) {
        console.log(formatLogMessage('debug', '=== Adblock Statistics ==='));
        const blockRate = ((adblockStats.blocked / (adblockStats.blocked + adblockStats.allowed)) * 100).toFixed(1);
        console.log(formatLogMessage('debug', `Blocked: ${adblockStats.blocked} requests (${blockRate}% block rate), Allowed: ${adblockStats.allowed}`));
+
+       // Engine-specific stats from the matcher itself. Both engines expose
+       // getStats() but with slightly different cache shapes — JS engine
+       // tracks urlCacheSize + resultCacheSize separately, rust wrapper
+       // tracks a single size. Handle both.
+       if (adblockMatcher && typeof adblockMatcher.getStats === 'function') {
+         try {
+           const es = adblockMatcher.getStats();
+           const engine = es.engine || 'js';
+           console.log(formatLogMessage('debug', `Engine: ${engine}${es.fromDiskCache ? ' (loaded from disk cache)' : ''}`));
+           if (es.cache && (es.cache.hits != null || es.cache.misses != null)) {
+             // rust wrapper: single `size`; JS engine: split into urlCacheSize + resultCacheSize
+             const sizeDesc = es.cache.size != null
+               ? `${es.cache.size}/${es.cache.maxSize}`
+               : `url ${es.cache.urlCacheSize}, result ${es.cache.resultCacheSize}, cap ${es.cache.maxSize}`;
+             console.log(formatLogMessage('debug', `Matcher cache: ${es.cache.hits} hits / ${es.cache.misses} misses (${es.cache.hitRate}), ${sizeDesc}`));
+           }
+           if (es.exceptions != null && es.exceptions > 0) {
+             console.log(formatLogMessage('debug', `Whitelist exceptions: ${es.exceptions}`));
+           }
+           if (es.errors != null && es.errors > 0) {
+             console.log(formatLogMessage('debug', `Engine errors: ${es.errors}`));
+           }
+         } catch (_) { /* getStats shape mismatch — don't crash the exit path */ }
+       }
      }
     if (smartCache) {
     const cacheStats = smartCache.getStats();  
@@ -4960,8 +5105,17 @@ function setupFrameHandling(page, forceDebug) {
     }
   }
   
+  // Run the same cleanup the SIGINT/SIGTERM emergency handler does, so normal
+  // scan completion isn't left depending on process.exit(0) to override
+  // lingering setInterval handles (the cloudflare detection cache schedules
+  // one that's otherwise only stopped on signal-driven shutdown).
+  try { cleanupCloudflareCache(); } catch (_) {}
+  try { wgDisconnectAll(forceDebug); } catch (_) {}
+  try { ovpnDisconnectAll(forceDebug); } catch (_) {}
+  try { purgeStaleTrackers(); } catch (_) {}
+
   // Clean process termination
   if (forceDebug) console.log(formatLogMessage('debug', `About to exit process...`));
   process.exit(0);
-  
+
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanboynz/network-scanner",
-  "version": "2.0.63",
+  "version": "2.0.65",
   "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": {
@@ -11,8 +11,8 @@
   },
   "dependencies": {
     "ghost-cursor": "^1.4.2",
-    "lru-cache": "^10.4.3",
-    "p-limit": "^4.0.0",
+    "lru-cache": "^11.3.5",
+    "p-limit": "^7.3.0",
     "psl": "^1.15.0",
     "puppeteer": ">=20.0.0"
   },
@@ -36,7 +36,7 @@
   "author": "FanboyNZ",
   "license": "GPL-3.0",
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "repository": {
     "type": "git",
@@ -50,10 +50,11 @@
   },
   "homepage": "https://github.com/ryanbr/network-scanner",
   "optionalDependencies": {
+    "adblock-rs": "^0.12.3",
     "puppeteer-core": ">=20.0.0"
   },
   "devDependencies": {
     "eslint": "^10.0.2",
-    "globals": "^16.3.0"
+    "globals": "^17.6.0"
   }
 }