@fanboynz/network-scanner 2.0.53 → 2.0.55

package/lib/browserexit.js

@@ -15,7 +15,7 @@ const CHROME_TEMP_PATHS = [
 ];
 
 const CHROME_TEMP_PATTERNS = [
-  '.com.google.Chrome.*',        // Google Chrome temp files
+  'com.google.Chrome.*',         // Google Chrome temp files (no leading dot)
   '.org.chromium.Chromium.*',
   'puppeteer-*'
 ];
@@ -39,6 +39,7 @@ async function cleanupChromeTempFiles(options = {}) {
 
     // Base cleanup commands for standard temp directories
     const cleanupCommands = [
+      'rm -rf /tmp/com.google.Chrome.* 2>/dev/null || true',
       'rm -rf /tmp/.com.google.Chrome.* 2>/dev/null || true',
       'rm -rf /tmp/.org.chromium.Chromium.* 2>/dev/null || true',
       'rm -rf /tmp/puppeteer-* 2>/dev/null || true',
@@ -48,6 +49,7 @@ async function cleanupChromeTempFiles(options = {}) {
 
     // Add snap-specific cleanup if requested
     if (includeSnapTemp || comprehensive) {
+      cleanupCommands.push('rm -rf /dev/shm/com.google.Chrome.* 2>/dev/null || true');
       cleanupCommands.push(
         'rm -rf /tmp/snap-private-tmp/snap.chromium/tmp/.org.chromium.Chromium.* 2>/dev/null || true',
         'rm -rf /tmp/snap-private-tmp/snap.chromium/tmp/puppeteer-* 2>/dev/null || true'

package/lib/fingerprint.js

@@ -24,28 +24,6 @@ function seededRandom(seed) {
 const _fingerprintCache = new Map();
 
 // Type-specific property spoofing functions for monomorphic optimization
-function spoofNavigatorProperties(navigator, properties, options = {}) {
-  if (!navigator || typeof navigator !== 'object') return false;
-  
-  for (const [prop, descriptor] of Object.entries(properties)) {
-    if (!safeDefineProperty(navigator, prop, descriptor, options)) {
-      if (options.debug) console.log(`[fingerprint] Failed to spoof navigator.${prop}`);
-    }
-  }
-  return true;
-}
-
-function spoofScreenProperties(screen, properties, options = {}) {
-  if (!screen || typeof screen !== 'object') return false;
-  
-  for (const [prop, descriptor] of Object.entries(properties)) {
-    if (!safeDefineProperty(screen, prop, descriptor, options)) {
-      if (options.debug) console.log(`[fingerprint] Failed to spoof screen.${prop}`);
-    }
-  }
-  return true;
-}
-
 // Built-in properties that should not be modified
 const BUILT_IN_PROPERTIES = new Set([
   'href', 'origin', 'protocol', 'host', 'hostname', 'port', 'pathname', 'search', 'hash',
@@ -379,6 +357,27 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
             return false;
           };
         })();
+
+        // Function.prototype.toString protection — make spoofed functions appear native
+        // Must be installed BEFORE any property overrides so all spoofs are protected
+        const nativeFunctionStore = new WeakMap();
+        const originalToString = Function.prototype.toString;
+        
+        function maskAsNative(fn, nativeName) {
+          if (typeof fn === 'function') {
+            nativeFunctionStore.set(fn, nativeName || fn.name || '');
+          }
+          return fn;
+        }
+        
+        Function.prototype.toString = function() {
+          if (nativeFunctionStore.has(this)) {
+            return `function ${nativeFunctionStore.get(this)}() { [native code] }`;
+          }
+          return originalToString.call(this);
+        };
+        // Protect the toString override itself
+        nativeFunctionStore.set(Function.prototype.toString, 'toString');
         
         // Create safe property definition helper
         function safeDefinePropertyLocal(target, property, descriptor) {
@@ -439,10 +438,14 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         // Remove webdriver properties
         //
         safeExecute(() => {
-          try {
-            delete navigator.webdriver;
-          } catch (e) {}
-          safeDefinePropertyLocal(navigator, 'webdriver', { get: () => false });
+          // In real Chrome, webdriver lives on Navigator.prototype, not the instance.
+          // Override it there so Object.getOwnPropertyDescriptor(navigator, 'webdriver') returns undefined.
+          try { delete navigator.webdriver; } catch (e) {}
+          Object.defineProperty(Navigator.prototype, 'webdriver', {
+            get: () => false,
+            configurable: true,
+            enumerable: true
+          });
         }, 'webdriver removal');
 
         // Remove automation properties
@@ -861,6 +864,8 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
                 if (typeof originalStack === 'string') {
                   return originalStack
                     .replace(/.*puppeteer.*\n?/gi, '')
+                    .replace(/.*__puppeteer_evaluation_script__.*\n?/gi, '')
+                    .replace(/.*evaluateOnNewDocument.*\n?/gi, '')
                     .replace(/.*chrome-devtools.*\n?/gi, '')
                     .replace(/.*webdriver.*\n?/gi, '')
                     .replace(/.*automation.*\n?/gi, '')
@@ -1023,8 +1028,9 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
 
             // Null context — return mock to prevent crashes
             if (ctx === null) {
-              return new Proxy({}, {
-                get(_, prop) {
+              const canvasEl = this; // capture the actual canvas element
+              const mock = new Proxy({}, {
+                get(target, prop) {
                   if (prop === 'getShaderPrecisionFormat') return () => ({ rangeMin: 127, rangeMax: 127, precision: 23 });
                   if (prop === 'getParameter') return (p) => webglSpoofParams[p] || 0;
                   if (prop === 'getSupportedExtensions') return () => [];
@@ -1032,12 +1038,28 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
                     if (name === 'WEBGL_debug_renderer_info') return { UNMASKED_VENDOR_WEBGL: 37445, UNMASKED_RENDERER_WEBGL: 37446 };
                     return null;
                   };
-                  if (prop === 'canvas') return this;
-                  if (prop === 'drawingBufferWidth') return 1920;
-                  if (prop === 'drawingBufferHeight') return 1080;
+                  if (prop === 'getContextAttributes') return () => ({
+                    alpha: true, antialias: true, depth: true, failIfMajorPerformanceCaveat: false,
+                    desynchronized: false, premultipliedAlpha: true, preserveDrawingBuffer: false,
+                    powerPreference: 'default', stencil: false, xrCompatible: false
+                  });
+                  if (prop === 'isContextLost') return () => false;
+                  if (prop === 'canvas') return canvasEl;
+                  if (prop === 'drawingBufferWidth') return canvasEl.width || 1920;
+                  if (prop === 'drawingBufferHeight') return canvasEl.height || 1080;
+                  if (prop === 'drawingBufferColorSpace') return 'srgb';
+                  // Identity — let prototype chain handle constructor/toString/Symbol.toStringTag
+                  if (prop === 'constructor') return WebGLRenderingContext;
+                  if (prop === Symbol.toStringTag) return 'WebGLRenderingContext';
+                  // Common draw/state methods — return noop to prevent crashes
                   return noop;
                 }
               });
+              // Make mock pass instanceof checks
+              if (window.WebGLRenderingContext) {
+                Object.setPrototypeOf(mock, WebGLRenderingContext.prototype);
+              }
+              return mock;
             }
 
             // Real context — wrap in Proxy to intercept getParameter/getExtension
@@ -1618,6 +1640,55 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           });
         }, 'location URL masking');
 
+        // Bulk-mask all spoofed prototype methods so toString() returns "[native code]"
+        // Must run AFTER all overrides are applied
+        safeExecute(() => {
+          const protoMasks = [
+            [WebGLRenderingContext.prototype, ['getParameter', 'getExtension', 'getSupportedExtensions']],
+            [HTMLCanvasElement.prototype, ['getContext', 'toDataURL', 'toBlob']],
+            [CanvasRenderingContext2D.prototype, ['getImageData', 'fillText', 'strokeText', 'measureText']],
+            [EventTarget.prototype, ['addEventListener', 'removeEventListener']],
+            [Date.prototype, ['getTimezoneOffset']],
+          ];
+          if (typeof WebGL2RenderingContext !== 'undefined') {
+            protoMasks.push([WebGL2RenderingContext.prototype, ['getParameter', 'getExtension']]);
+          }
+          protoMasks.forEach(([proto, methods]) => {
+            methods.forEach(name => {
+              if (typeof proto[name] === 'function') maskAsNative(proto[name], name);
+            });
+          });
+
+          // Mask navigator/window method overrides
+          if (typeof navigator.permissions?.query === 'function') maskAsNative(navigator.permissions.query, 'query');
+          if (typeof navigator.getBattery === 'function') maskAsNative(navigator.getBattery, 'getBattery');
+          if (typeof speechSynthesis?.getVoices === 'function') maskAsNative(speechSynthesis.getVoices, 'getVoices');
+          if (typeof performance.now === 'function') maskAsNative(performance.now, 'now');
+          if (typeof Notification?.requestPermission === 'function') maskAsNative(Notification.requestPermission, 'requestPermission');
+          if (typeof window.RTCPeerConnection === 'function') maskAsNative(window.RTCPeerConnection, 'RTCPeerConnection');
+          if (typeof window.Image === 'function') maskAsNative(window.Image, 'Image');
+          if (typeof window.fetch === 'function') maskAsNative(window.fetch, 'fetch');
+          if (typeof window.PointerEvent === 'function') maskAsNative(window.PointerEvent, 'PointerEvent');
+
+          // Mask property getters on navigator
+          const navProps = ['userAgentData', 'connection', 'pdfViewerEnabled', 'webdriver',
+                            'hardwareConcurrency', 'deviceMemory', 'platform', 'maxTouchPoints'];
+          navProps.forEach(prop => {
+            // Check both instance and prototype (webdriver lives on prototype)
+            const desc = Object.getOwnPropertyDescriptor(navigator, prop)
+                      || Object.getOwnPropertyDescriptor(Navigator.prototype, prop);
+            if (desc?.get) maskAsNative(desc.get, 'get ' + prop);
+          });
+
+          // Mask window property getters
+          ['screenX', 'screenY', 'outerWidth', 'outerHeight'].forEach(prop => {
+            const desc = Object.getOwnPropertyDescriptor(window, prop);
+            if (desc?.get) maskAsNative(desc.get, 'get ' + prop);
+          });
+
+          if (debugEnabled) console.log('[fingerprint] toString protection applied to all spoofed functions');
+        }, 'Function.prototype.toString bulk masking');
+
       }, ua, forceDebug, selectedGpu);
     } catch (stealthErr) {
       if (stealthErr.message.includes('Session closed') || 
@@ -2013,9 +2084,6 @@ async function applyAllFingerprintSpoofing(page, siteConfig, forceDebug, current
 }
 
 // Legacy compatibility function - maintained for backwards compatibility
-function safeExecuteSpoofing(spoofFunction, description, forceDebug = false) {
-  return safeSpoofingExecution(spoofFunction, description, { debug: forceDebug });
-}
 
 
 module.exports = {
@@ -2027,7 +2095,6 @@ module.exports = {
   applyAllFingerprintSpoofing,
   simulateHumanBehavior,
   safeDefineProperty,
-  safeExecuteSpoofing, // Legacy compatibility
   safeSpoofingExecution,
   DEFAULT_PLATFORM,
   DEFAULT_TIMEZONE

package/lib/interaction.js

@@ -123,6 +123,20 @@ const ELEMENT_INTERACTION = {
   MISTAKE_RATE: 0.02         // Probability of typing mistakes (0.02 = 2% chance)
 };
 
+// === CONTENT CLICK CONSTANTS ===
+// For triggering document-level onclick handlers (e.g., Monetag onclick_static)
+// These clicks target the page content area, not specific UI elements
+// NOTE: No preDelay needed — mouse movements + scrolling already provide ~1s
+// of activity before clicks fire, which is enough for async ad script registration
+const CONTENT_CLICK = {
+  CLICK_COUNT: 2,            // Two attempts (primary + backup if first suppressed)
+  INTER_CLICK_MIN: 300,      // Minimum ms between clicks (above Monetag 250ms cooldown)
+  INTER_CLICK_MAX: 500,      // Maximum ms between clicks
+  PRE_CLICK_DELAY: 300,      // Small buffer for late-loading async ad scripts
+  VIEWPORT_INSET: 0.2,       // Avoid outer 20% of viewport (menus, overlays)
+  MOUSE_APPROACH_STEPS: 3    // Minimal steps — just enough for non-instant movement
+};
+
 // === INTENSITY SETTINGS ===
 // Pre-configured intensity levels - modify these to change overall behavior
 const INTENSITY_SETTINGS = {
@@ -606,6 +620,97 @@ async function interactWithElements(page, options = {}) {
   }
 }
 
+/**
+ * Clicks random spots in the page content area to trigger document-level
+ * onclick handlers (Monetag onclick_static, similar popunder SDKs).
+ *
+ * WHY THIS EXISTS:
+ * Ad onclick SDKs attach a single listener on `document` (capture phase)
+ * that fires on ANY click with `isTrusted: true`. They don't care which
+ * element was clicked — just that a real input event reached the document.
+ * `interactWithElements()` hunts for <button>/<a> which may not exist or
+ * may be excluded by the SDK's own filter. This function simply clicks
+ * the content area of the page where the SDK will always accept the event.
+ *
+ * TIMING:
+ * - 300ms preDelay: small buffer after mouse/scroll activity (~1.2s) for
+ *   any late-loading async ad scripts to finish registering listeners.
+ * - Spaces clicks 300-500ms apart (above Monetag's 250ms cooldown).
+ * - Total time: ~1.1s for 2 clicks (preDelay + move + pause + click + gap).
+ *
+ * TARGETING:
+ * - Clicks within the inner 60% of the viewport to avoid sticky headers,
+ *   footers, sidebars, cookie banners, and overlay close buttons.
+ * - Each click gets a fresh random position with natural mouse approach.
+ *
+ * @param {import('puppeteer').Page} page
+ * @param {object} [options]
+ * @param {number} [options.clicks]         Number of click attempts
+ * @param {number} [options.preDelay]       Ms to wait before first click
+ * @param {number} [options.interClickMin]  Min ms between clicks
+ * @param {number} [options.interClickMax]  Max ms between clicks
+ * @param {boolean} [options.forceDebug]    Log click coordinates
+ */
+async function performContentClicks(page, options = {}) {
+  const {
+    clicks = CONTENT_CLICK.CLICK_COUNT,
+    preDelay = CONTENT_CLICK.PRE_CLICK_DELAY,
+    interClickMin = CONTENT_CLICK.INTER_CLICK_MIN,
+    interClickMax = CONTENT_CLICK.INTER_CLICK_MAX,
+    forceDebug = false
+  } = options;
+
+  try {
+    if (page.isClosed()) return;
+
+    const viewport = await getCachedViewport(page);
+    const inset = CONTENT_CLICK.VIEWPORT_INSET;
+    const minX = Math.floor(viewport.width * inset);
+    const maxX = Math.floor(viewport.width * (1 - inset));
+    const minY = Math.floor(viewport.height * inset);
+    const maxY = Math.floor(viewport.height * (1 - inset));
+
+    // Wait for ad scripts to register their listeners
+    await fastTimeout(preDelay);
+
+    let lastX = minX + Math.floor(Math.random() * (maxX - minX));
+    let lastY = minY + Math.floor(Math.random() * (maxY - minY));
+
+    for (let i = 0; i < clicks; i++) {
+      if (page.isClosed()) break;
+
+      // Random position in content zone
+      const targetX = minX + Math.floor(Math.random() * (maxX - minX));
+      const targetY = minY + Math.floor(Math.random() * (maxY - minY));
+
+      // Natural mouse approach (few steps, no need for elaborate curves)
+      await humanLikeMouseMove(page, lastX, lastY, targetX, targetY, {
+        steps: CONTENT_CLICK.MOUSE_APPROACH_STEPS,
+        curve: 0.03 + Math.random() * 0.04,
+        jitter: 1
+      });
+
+      // Brief human-like pause, then click
+      await fastTimeout(TIMING.CLICK_PAUSE_MIN + Math.random() * (TIMING.CLICK_PAUSE_MAX - TIMING.CLICK_PAUSE_MIN));
+      await page.mouse.click(targetX, targetY);
+
+      if (forceDebug) {
+        console.log(`[interaction] Content click ${i + 1}/${clicks} at (${targetX}, ${targetY})`);
+      }
+
+      lastX = targetX;
+      lastY = targetY;
+
+      // Inter-click gap (skip after last click)
+      if (i < clicks - 1) {
+        await fastTimeout(interClickMin + Math.random() * (interClickMax - interClickMin));
+      }
+    }
+  } catch (err) {
+    // Content clicks are supplementary — never break the scan
+  }
+}
+
 /**
  * Simulates realistic typing behavior with human characteristics
  * 
@@ -876,12 +981,22 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
       }
     }
 
-    // Element interaction
+    // Click interaction — two strategies for maximum ad script coverage
+    // 1. Content area clicks: triggers document-level onclick handlers
+    //    (Monetag, similar popunder SDKs that listen on document)
+    // 2. Element clicks: interacts with specific UI elements
+    //    (ad scripts that attach to specific clickable elements)
     if (includeElementClicks) {
-      await interactWithElements(page, {
-        maxAttempts: 2,
-        avoidDestructive: true
-      });
+      if (checkTimeout()) return; // Emergency timeout check
+      // Primary: content area clicks for document-level onclick handlers
+      await performContentClicks(page, { forceDebug });
+      // Secondary: targeted element clicks (fast, 1 attempt only)
+      if (!checkTimeout()) {
+        await interactWithElements(page, {
+          maxAttempts: 1,
+          avoidDestructive: true
+        });
+      }
     }
 
     // Periodic memory cleanup during interaction
@@ -1105,6 +1220,7 @@ module.exports = {
   humanLikeMouseMove,
   simulateScrolling,
   interactWithElements,
+  performContentClicks,
   simulateTyping,
   generateRandomCoordinates
 };

package/lib/nettools.js

@@ -11,6 +11,20 @@ const execPromise = util.promisify(exec);
 // Cycling index for whois server rotation
 let whoisServerCycleIndex = 0;
 
+// Global dig result cache — shared across ALL handler instances and processUrl calls
+// Key: `${domain}-${recordType}`, Value: { result, timestamp }
+// DNS records don't change based on what terms you're searching for,
+// so we cache the raw dig output and let each handler check its own terms against it
+const globalDigResultCache = new Map();
+const GLOBAL_DIG_CACHE_TTL = 300000; // 5 minutes
+const GLOBAL_DIG_CACHE_MAX = 500;
+
+// Global whois result cache — shared across ALL handler instances and processUrl calls
+// Whois data is per root domain and doesn't change based on search terms
+const globalWhoisResultCache = new Map();
+const GLOBAL_WHOIS_CACHE_TTL = 900000; // 15 minutes (whois data changes less frequently)
+const GLOBAL_WHOIS_CACHE_MAX = 500;
+
 /**
  * Strips ANSI color codes from a string for clean file logging
  * @param {string} text - Text that may contain ANSI codes
@@ -26,27 +40,28 @@ function stripAnsiColors(text) {
  * @returns {Object} Object with isAvailable boolean and version/error info
  */
 function validateWhoisAvailability() {
+  if (validateWhoisAvailability._cached) return validateWhoisAvailability._cached;
   try {
     const result = execSync('whois --version 2>&1', { encoding: 'utf8' });
-    return {
+    validateWhoisAvailability._cached = {
       isAvailable: true,
       version: result.trim()
     };
   } catch (error) {
-    // Some systems don't have --version, try just whois
     try {
       execSync('which whois', { encoding: 'utf8' });
-      return {
+      validateWhoisAvailability._cached = {
         isAvailable: true,
         version: 'whois (version unknown)'
       };
     } catch (e) {
-      return {
+      validateWhoisAvailability._cached = {
         isAvailable: false,
         error: 'whois command not found'
       };
     }
   }
+  return validateWhoisAvailability._cached;
 }
 
 /**
@@ -54,18 +69,20 @@ function validateWhoisAvailability() {
  * @returns {Object} Object with isAvailable boolean and version/error info
  */
 function validateDigAvailability() {
+  if (validateDigAvailability._cached) return validateDigAvailability._cached;
   try {
     const result = execSync('dig -v 2>&1', { encoding: 'utf8' });
-    return {
+    validateDigAvailability._cached = {
       isAvailable: true,
       version: result.split('\n')[0].trim()
     };
   } catch (error) {
-    return {
+    validateDigAvailability._cached = {
       isAvailable: false,
       error: 'dig command not found'
     };
   }
+  return validateDigAvailability._cached;
 }
 
 /**
@@ -635,8 +652,8 @@ async function digLookup(domain = '', recordType = 'A', timeout = 5000) {
     // Clean domain
     const cleanDomain = domain.replace(/^https?:\/\//, '').replace(/\/.*$/, '').replace(/:\d+$/, '');
     
-    // Get short output first
-    const { stdout, stderr } = await execWithTimeout(`dig +short "${cleanDomain}" ${recordType}`, timeout);
+    // Single dig command — full output contains everything including the short answers
+    const { stdout: fullOutput, stderr } = await execWithTimeout(`dig "${cleanDomain}" ${recordType}`, timeout);
     
     if (stderr && stderr.trim()) {
       return {
@@ -647,13 +664,21 @@ async function digLookup(domain = '', recordType = 'A', timeout = 5000) {
       };
     }
     
-    // Also get full dig output for detailed analysis
-    const { stdout: fullOutput } = await execWithTimeout(`dig "${cleanDomain}" ${recordType}`, timeout);
+    // Extract short output from ANSWER SECTION of full dig output
+    const answerMatch = fullOutput.match(/;; ANSWER SECTION:\n([\s\S]*?)(?:\n;;|\n*$)/);
+    let shortOutput = '';
+    if (answerMatch) {
+      shortOutput = answerMatch[1]
+        .split('\n')
+        .map(line => line.split(/\s+/).pop())
+        .filter(Boolean)
+        .join('\n');
+    }
     
     return {
       success: true,
       output: fullOutput,
-      shortOutput: stdout.trim(),
+      shortOutput,
       domain: cleanDomain,
       recordType
     };
@@ -766,7 +791,6 @@ function createNetToolsHandler(config) {
     whoisDelay = 4000,
     whoisServer,
     whoisServerMode = 'random',
-    bufferedLogWrite = null,
     debugLogFile = null,
     digTerms,
     digOrTerms,
@@ -807,20 +831,10 @@ function createNetToolsHandler(config) {
     subdomain: digSubdomain
   });
 
-  // Add whois resolution caching to avoid redundant whois lookups
-  const whoisResultCache = new Map();
-  const WHOIS_CACHE_TTL = 900000; // 15 minutes cache TTL (whois data changes less frequently)
-  const MAX_CACHE_SIZE = 400; // Larger cache for whois due to longer TTL
-  // Size          Memory
-  // 100          ~900KB
-  // 200          1.8MB
-  // 300          2.6MB
-  // 400          3.4MB
-  // 500          4.2MB  
-  // Add DNS resolution caching to avoid redundant dig lookups
-  const digResultCache = new Map();
-  const DIG_CACHE_TTL = 300000; // 5 minutes cache TTL
-  const DIG_MAX_CACHE_SIZE = 400; // Smaller cache for dig due to shorter TTL
+  // Whois cache is global (globalWhoisResultCache) — shared across all handler instances
+  // Whois data is per root domain and doesn't change based on search terms
+  // Dig cache is global (globalDigResultCache) — shared across all handler instances
+  // DNS results are the same regardless of search terms
   
   return async function handleNetToolsCheck(domain, fullSubdomain) {
     // Use fullSubdomain parameter instead of originalDomain to maintain consistency
@@ -844,19 +858,17 @@ function createNetToolsHandler(config) {
 
     // Move the logToConsoleAndFile function declaration from later in the file to here:
     function logToConsoleAndFile(message) {
+      // Note: This function needs access to forceDebug, debugLogFile, and fs from the parent scope
+      // These are passed in via the config object to createNetToolsHandler
+      // forceDebug, debugLogFile, and fs are available in this closure
+
+      // Always log to console when in debug mode
       if (forceDebug) {
         console.log(formatLogMessage('debug', message));
       }
       
-      if (debugLogFile && bufferedLogWrite) {
-        try {
-          const timestamp = new Date().toISOString();
-          const cleanMessage = stripAnsiColors(message);
-          bufferedLogWrite(debugLogFile, `${timestamp} [debug nettools] ${cleanMessage}\n`);
-        } catch (logErr) {
-          // Silently fail file logging to avoid disrupting whois operations
-        }
-      } else if (debugLogFile && fs) {
+      // Also log to file if debug file logging is enabled
+      if (debugLogFile && fs) {
         try {
           const timestamp = new Date().toISOString();
           const cleanMessage = stripAnsiColors(message);
@@ -982,9 +994,9 @@ function createNetToolsHandler(config) {
         const now = Date.now();
         let whoisResult = null;
         
-        if (whoisResultCache.has(whoisCacheKey)) {
-          const cachedEntry = whoisResultCache.get(whoisCacheKey);
-          if (now - cachedEntry.timestamp < WHOIS_CACHE_TTL) {
+        if (globalWhoisResultCache.has(whoisCacheKey)) {
+          const cachedEntry = globalWhoisResultCache.get(whoisCacheKey);
+          if (now - cachedEntry.timestamp < GLOBAL_WHOIS_CACHE_TTL) {
             if (forceDebug) {
               const age = Math.round((now - cachedEntry.timestamp) / 1000);
               const serverInfo = (selectedServer && selectedServer !== '') ? ` (server: ${selectedServer})` : ' (default server)';
@@ -998,7 +1010,7 @@ function createNetToolsHandler(config) {
             });
           } else {
             // Cache expired, remove it
-            whoisResultCache.delete(whoisCacheKey);
+            globalWhoisResultCache.delete(whoisCacheKey);
             if (forceDebug) {
               logToConsoleAndFile(`${messageColors.highlight('[whois-cache]')} Cache expired for ${whoisRootDomain}, performing fresh lookup`);
             }
@@ -1030,7 +1042,7 @@ function createNetToolsHandler(config) {
                  !whoisResult.error.toLowerCase().includes('connection') &&
                  !whoisResult.error.toLowerCase().includes('network'))) {
               
-              whoisResultCache.set(whoisCacheKey, {
+              globalWhoisResultCache.set(whoisCacheKey, {
                 result: whoisResult,
                 timestamp: now
               });
@@ -1183,17 +1195,17 @@ function createNetToolsHandler(config) {
         }
         
         // Periodic whois cache cleanup to prevent memory leaks
-        if (whoisResultCache.size > MAX_CACHE_SIZE) {
+        if (globalWhoisResultCache.size > GLOBAL_WHOIS_CACHE_MAX) {
           const now = Date.now();
           let cleanedCount = 0;
-          for (const [key, entry] of whoisResultCache.entries()) {
-            if (now - entry.timestamp > WHOIS_CACHE_TTL) {
-              whoisResultCache.delete(key);
+          for (const [key, entry] of globalWhoisResultCache.entries()) {
+            if (now - entry.timestamp > GLOBAL_WHOIS_CACHE_TTL) {
+              globalWhoisResultCache.delete(key);
               cleanedCount++;
             }
           }
           if (forceDebug && cleanedCount > 0) {
-            logToConsoleAndFile(`${messageColors.highlight('[whois-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${whoisResultCache.size}`);
+            logToConsoleAndFile(`${messageColors.highlight('[whois-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${globalWhoisResultCache.size}`);
           }
         }
       }
@@ -1216,16 +1228,16 @@ function createNetToolsHandler(config) {
           const now = Date.now();
           let digResult = null;
           
-          if (digResultCache.has(digCacheKey)) {
-            const cachedEntry = digResultCache.get(digCacheKey);
-            if (now - cachedEntry.timestamp < DIG_CACHE_TTL) {
+          if (globalDigResultCache.has(digCacheKey)) {
+            const cachedEntry = globalDigResultCache.get(digCacheKey);
+            if (now - cachedEntry.timestamp < GLOBAL_DIG_CACHE_TTL) {
               if (forceDebug) {
                 logToConsoleAndFile(`${messageColors.highlight('[dig-cache]')} Using cached result for ${digDomain} (${digRecordType}) [age: ${Math.round((now - cachedEntry.timestamp) / 1000)}s]`);
               }
               digResult = cachedEntry.result;
             } else {
               // Cache expired, remove it
-              digResultCache.delete(digCacheKey);
+              globalDigResultCache.delete(digCacheKey);
             }
           }
           
@@ -1233,7 +1245,7 @@ function createNetToolsHandler(config) {
           digResult = await digLookup(digDomain, digRecordType, 5000); // 5 second timeout for dig
             
             // Cache the result for future use
-            digResultCache.set(digCacheKey, {
+            globalDigResultCache.set(digCacheKey, {
               result: digResult,
               timestamp: now
             });
@@ -1303,17 +1315,17 @@ function createNetToolsHandler(config) {
         }
         
         // Periodic dig cache cleanup to prevent memory leaks
-        if (digResultCache.size > DIG_MAX_CACHE_SIZE) {
+        if (globalDigResultCache.size > GLOBAL_DIG_CACHE_MAX) {
           const now = Date.now();
           let cleanedCount = 0;
-          for (const [key, entry] of digResultCache.entries()) {
-            if (now - entry.timestamp > DIG_CACHE_TTL) {
-              digResultCache.delete(key);
+          for (const [key, entry] of globalDigResultCache.entries()) {
+            if (now - entry.timestamp > GLOBAL_DIG_CACHE_TTL) {
+              globalDigResultCache.delete(key);
               cleanedCount++;
             }
           }
           if (forceDebug && cleanedCount > 0) {
-            logToConsoleAndFile(`${messageColors.highlight('[dig-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${digResultCache.size}`);
+            logToConsoleAndFile(`${messageColors.highlight('[dig-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${globalDigResultCache.size}`);
           }
         }
       }
@@ -1387,12 +1399,7 @@ function createNetToolsHandler(config) {
           
           // Add whois server info to log if custom server was used
           const serverInfo = whoisServer ? ` (whois-server: ${selectWhoisServer(whoisServer)})` : '';
-          const logLine = `${timestamp} [match][${simplifiedUrl}] ${domain} (${matchType.join(' + ')})${serverInfo}\n`;
-          if (bufferedLogWrite) {
-            bufferedLogWrite(matchedUrlsLogFile, logLine);
-          } else {
-            fs.appendFileSync(matchedUrlsLogFile, logLine);
-          }
+          fs.appendFileSync(matchedUrlsLogFile, `${timestamp} [match][${simplifiedUrl}] ${domain} (${matchType.join(' + ')})${serverInfo}\n`);
         }
       }
       

package/nwss.js

@@ -39,7 +39,7 @@ const { processResults } = require('./lib/post-processing');
 // Colorize various text when used
 const { colorize, colors, messageColors, tags, formatLogMessage } = require('./lib/colorize');
 // Enhanced mouse interaction and page simulation
-const { performPageInteraction, createInteractionConfig } = require('./lib/interaction');
+const { performPageInteraction, createInteractionConfig, performContentClicks, humanLikeMouseMove } = require('./lib/interaction');
 // Domain detection cache for performance optimization
 const { createGlobalHelpers, getTotalDomainsSkipped, getDetectedDomainsCount } = require('./lib/domain-cache');
 const { createSmartCache } = require('./lib/smart-cache'); // Smart cache system
@@ -1447,7 +1447,6 @@ function setupFrameHandling(page, forceDebug) {
         '--disable-features=SafeBrowsing',
         '--disable-dev-shm-usage',
         '--disable-sync',
-        '--use-gl=swiftshader',  // Software WebGL — prevents ad script crashes in headless
         '--mute-audio',
         '--disable-translate',
         '--window-size=1920,1080',
@@ -2730,9 +2729,7 @@ function setupFrameHandling(page, forceDebug) {
                 whoisDelay: siteConfig.whois_delay !== undefined ? siteConfig.whois_delay : whois_delay,
                 whoisServer,
                 whoisServerMode: siteConfig.whois_server_mode || whois_server_mode,
-                bufferedLogWrite,
                 debugLogFile,
-                fs,
                 digTerms,
                 digOrTerms,
                 digRecordType,
@@ -2838,9 +2835,7 @@ function setupFrameHandling(page, forceDebug) {
                whoisDelay: siteConfig.whois_delay !== undefined ? siteConfig.whois_delay : whois_delay, // Site-specific or global fallback
 	       whoisServer, // Pass whois server configuration
                whoisServerMode: siteConfig.whois_server_mode || whois_server_mode,
-               bufferedLogWrite,
-               debugLogFile, // Pass debug log file for whois error logging
-               fs, // Pass fs module for file operations
+               debugLogFile,
                digTerms,
                digOrTerms,
                digRecordType,
@@ -3664,6 +3659,32 @@ function setupFrameHandling(page, forceDebug) {
           }
         }
 
+      // Post-reload interaction: trigger onclick ad scripts (Monetag etc.)
+      // Each reload gives a fresh session with a new random ad domain —
+      // without clicks the SDK never fires and we miss those domains.
+      if (interactEnabled && !page.isClosed()) {
+        try {
+          // Brief wait for ad scripts to re-register after reload
+          await fastTimeout(800);
+          // Quick mouse moves to build movement score (Monetag tracks this)
+          const vp = page.viewport() || { width: 1920, height: 1080 };
+          const startX = 200 + Math.floor(Math.random() * (vp.width - 400));
+          const startY = 200 + Math.floor(Math.random() * (vp.height - 400));
+          await page.mouse.move(startX, startY);
+          for (let m = 0; m < 2; m++) {
+            const endX = 200 + Math.floor(Math.random() * (vp.width - 400));
+            const endY = 200 + Math.floor(Math.random() * (vp.height - 400));
+            await humanLikeMouseMove(page, startX, startY, endX, endY, { steps: 3, curve: 0.04, jitter: 1 });
+          }
+          // Content clicks to trigger document-level onclick handlers
+          await performContentClicks(page, { clicks: 2, preDelay: 200, forceDebug });
+          if (forceDebug) console.log(formatLogMessage('debug', `Post-reload interaction completed for reload #${i}`));
+        } catch (postReloadInteractErr) {
+          // Non-critical — continue with remaining reloads
+          if (forceDebug) console.log(formatLogMessage('debug', `Post-reload interaction failed: ${postReloadInteractErr.message}`));
+        }
+      }
+
       // Only add delay if we're continuing with more reloads
       if (i < totalReloads) {
     // Reduce delay for problematic sites

package/package.json

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