@fanboynz/network-scanner 1.0.65 → 1.0.67

package/lib/fingerprint.js

@@ -292,7 +292,11 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
               /tz check/i,
               /new window\\.Error.*<anonymous>/i,
               /Failed to load resource.*server responded with a status of 40[34]/i,
-              /Blocked script execution in 'about:blank'.*sandboxed.*allow-scripts/i
+              /Blocked script execution in 'about:blank'.*sandboxed.*allow-scripts/i,
+              /Page JavaScript error:/i,
+              /^[a-zA-Z0-9_$]+\[.*\]\s+is not a function/i,
+              /^[a-zA-Z0-9_$]+\(.*\)\s+is not a function/i,
+              /^[a-zA-Z0-9_$]+\.[a-zA-Z0-9_$]+.*is not a function/i
             ];
             return patterns.some(pattern => pattern.test(String(message || '')));
           }
@@ -568,6 +572,76 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'battery API spoofing');
 
         // Suppress common console errors
+
+        // Enhanced Mouse/Pointer Spoofing
+        safeExecute(() => {
+          // Spoof pointer capabilities
+          if (navigator.maxTouchPoints !== undefined) {
+            safeDefinePropertyLocal(navigator, 'maxTouchPoints', { 
+              get: () => Math.random() > 0.7 ? 0 : Math.floor(Math.random() * 5) + 1 
+            });
+          }
+          
+          // Spoof mouse timing patterns to prevent behavioral fingerprinting
+          const originalAddEventListener = EventTarget.prototype.addEventListener;
+          EventTarget.prototype.addEventListener = function(type, listener, options) {
+            if (type === 'mousemove' && typeof listener === 'function') {
+              const wrappedListener = function(event) {
+                // Add slight timing variation to prevent pattern detection
+                const delay = Math.random() * 2; // 0-2ms variation
+                setTimeout(() => listener.call(this, event), delay);
+              };
+              return originalAddEventListener.call(this, type, wrappedListener, options);
+            }
+            return originalAddEventListener.call(this, type, listener, options);
+          };
+          
+          // Spoof PointerEvent if available
+          if (window.PointerEvent) {
+            const OriginalPointerEvent = window.PointerEvent;
+            window.PointerEvent = function(type, eventInitDict = {}) {
+              // Add realistic pointer properties
+              const enhancedDict = {
+                ...eventInitDict,
+                pressure: eventInitDict.pressure || (Math.random() * 0.3 + 0.2), // 0.2-0.5
+                tangentialPressure: eventInitDict.tangentialPressure || 0,
+                tiltX: eventInitDict.tiltX || (Math.random() * 10 - 5), // -5 to 5
+                tiltY: eventInitDict.tiltY || (Math.random() * 10 - 5),
+                twist: eventInitDict.twist || Math.random() * 360,
+                pointerType: eventInitDict.pointerType || 'mouse'
+              };
+              return new OriginalPointerEvent(type, enhancedDict);
+            };
+            Object.setPrototypeOf(window.PointerEvent, OriginalPointerEvent);
+          }
+          
+          // Spoof touch capabilities for mobile detection evasion
+          if (!window.TouchEvent && Math.random() > 0.8) {
+            // 20% chance to add touch support to confuse fingerprinters
+            window.TouchEvent = function(type, eventInitDict = {}) {
+              return new MouseEvent(type, eventInitDict);
+            };
+            
+            safeDefinePropertyLocal(navigator, 'maxTouchPoints', { get: () => 1 });
+          }
+          
+          // Spoof mouse wheel behavior
+          const originalWheelEvent = window.WheelEvent;
+          if (originalWheelEvent) {
+            window.WheelEvent = function(type, eventInitDict = {}) {
+              const enhancedDict = {
+                ...eventInitDict,
+                deltaMode: eventInitDict.deltaMode || 0,
+                deltaX: eventInitDict.deltaX || 0,
+                deltaY: eventInitDict.deltaY || (Math.random() * 100 - 50),
+                deltaZ: eventInitDict.deltaZ || 0
+              };
+              return new originalWheelEvent(type, enhancedDict);
+            };
+          }
+          
+        }, 'enhanced mouse/pointer spoofing');
+
         safeExecute(() => {
           const originalConsoleError = console.error;
           console.error = function(...args) {
@@ -728,35 +802,98 @@ async function applyFingerprintProtection(page, siteConfig, forceDebug, currentU
 
 /**
  * Simulate human-like behavior
+ * Enhanced with realistic mouse patterns and timing
  */
 async function simulateHumanBehavior(page, forceDebug) {
   try {
     await page.evaluateOnNewDocument((debugEnabled) => {
       
       try {
-        let mouseX = Math.random() * window.innerWidth;
-        let mouseY = Math.random() * window.innerHeight;
+        // Enhanced human-like mouse simulation with realistic patterns
+        let mouseX = Math.random() * (window.innerWidth - 100) + 50;
+        let mouseY = Math.random() * (window.innerHeight - 100) + 50;
+        let lastMoveTime = Date.now();
+        let moveCount = 0;
+        
+        // Realistic mouse movement patterns
+        const movePatterns = {
+          linear: () => ({
+            deltaX: (Math.random() - 0.5) * 4,
+            deltaY: (Math.random() - 0.5) * 4
+          }),
+          curved: () => {
+            const angle = moveCount * 0.1;
+            return {
+              deltaX: Math.sin(angle) * 3 + (Math.random() - 0.5) * 2,
+              deltaY: Math.cos(angle) * 3 + (Math.random() - 0.5) * 2
+            };
+          },
+          jittery: () => ({
+            deltaX: (Math.random() - 0.5) * 8,
+            deltaY: (Math.random() - 0.5) * 8
+          })
+        };
+        
+        const patterns = Object.keys(movePatterns);
+        let currentPattern = patterns[Math.floor(Math.random() * patterns.length)];
+        let patternChangeCounter = 0;
         
         const moveInterval = setInterval(() => {
-          mouseX += (Math.random() - 0.5) * 20;
-          mouseY += (Math.random() - 0.5) * 20;
+          const now = Date.now();
+          const timeDelta = now - lastMoveTime;
           
-          mouseX = Math.max(0, Math.min(window.innerWidth, mouseX));
-          mouseY = Math.max(0, Math.min(window.innerHeight, mouseY));
+          // Change pattern occasionally
+          if (patternChangeCounter++ > 20 + Math.random() * 30) {
+            currentPattern = patterns[Math.floor(Math.random() * patterns.length)];
+            patternChangeCounter = 0;
+          }
+          
+          // Apply movement pattern
+          const movement = movePatterns[currentPattern]();
+          mouseX += movement.deltaX;
+          mouseY += movement.deltaY;
+          
+          // Keep within bounds with padding
+          mouseX = Math.max(10, Math.min(window.innerWidth - 10, mouseX));
+          mouseY = Math.max(10, Math.min(window.innerHeight - 10, mouseY));
           
           try {
+            // Dispatch realistic mouse events with varying timing
             document.dispatchEvent(new MouseEvent('mousemove', {
               clientX: mouseX,
               clientY: mouseY,
-              bubbles: true
+              bubbles: true,
+              cancelable: true,
+              view: window,
+              detail: 0,
+              buttons: 0,
+              button: 0
             }));
+
+            // Occasionally simulate clicks for more realistic behavior
+            if (Math.random() > 0.995) { // Very rare clicks
+              document.dispatchEvent(new MouseEvent('click', {
+                clientX: mouseX,
+                clientY: mouseY,
+                bubbles: true,
+                cancelable: true,
+                view: window
+              }));
+            }
+            
+            moveCount++;
+            lastMoveTime = now;
+
           } catch (e) {}
-        }, 1000 + Math.random() * 2000);
+        }, 50 + Math.random() * 100); // More frequent, realistic timing (50-150ms)
         
-        // Stop after 30 seconds
+        // Stop after 45 seconds with gradual slowdown
         setTimeout(() => {
-          try { clearInterval(moveInterval); } catch (e) {}
-        }, 30000);
+          try { 
+            clearInterval(moveInterval);
+            if (debugEnabled) console.log('[fingerprint] Enhanced mouse simulation completed');
+          } catch (e) {}
+        }, 45000);
         
       } catch (err) {
         if (debugEnabled) console.log(`[fingerprint] Human behavior simulation failed: ${err.message}`);

package/lib/interaction.js

@@ -164,6 +164,38 @@ const PROBABILITIES = {
   }
 };
 
+// === PERFORMANCE OPTIMIZATION VARIABLES ===
+// Viewport caching to reduce repeated page.viewport() calls
+let cachedViewport = null;
+let lastViewportCheck = 0;
+const VIEWPORT_CACHE_DURATION = 30000; // 30 seconds
+let interactionMemoryCleanupCounter = 0;
+
+/**
+ * Gets viewport dimensions with caching for performance
+ * Caches viewport for 30 seconds to avoid repeated queries
+ * 
+ * @param {import('puppeteer').Page} page - Puppeteer page object
+ * @returns {Promise<object>} Viewport dimensions {width, height}
+ */
+async function getCachedViewport(page) {
+  const now = Date.now();
+  
+  // Return cached viewport if still valid
+  if (cachedViewport && (now - lastViewportCheck) < VIEWPORT_CACHE_DURATION) {
+    return cachedViewport;
+  }
+  
+  try {
+    cachedViewport = await page.viewport();
+    lastViewportCheck = now;
+    return cachedViewport || { width: DEFAULT_VIEWPORT.WIDTH, height: DEFAULT_VIEWPORT.HEIGHT };
+  } catch (viewportErr) {
+    // Return defaults if viewport query fails
+    return { width: DEFAULT_VIEWPORT.WIDTH, height: DEFAULT_VIEWPORT.HEIGHT };
+  }
+}
+
 /**
  * Generates random coordinates within viewport bounds with intelligent placement
  * 
@@ -481,8 +513,8 @@ async function interactWithElements(page, options = {}) {
         return;
       }
 
-      // Shorter timeout for element interaction since body should already exist
-      await page.waitForSelector('body', { timeout: 2000 });
+      // Very short timeout since page should already be loaded
+      await page.waitForSelector('body', { timeout: 1000 });
     } catch (bodyWaitErr) {
       if (options.forceDebug) {
         console.log(`[interaction] Page not ready for element interaction: ${bodyWaitErr.message}`);
@@ -490,10 +522,10 @@ async function interactWithElements(page, options = {}) {
       return;
     }
 
-    // Get viewport dimensions for coordinate bounds
-    const viewport = await page.viewport();
-    const maxX = viewport ? viewport.width : DEFAULT_VIEWPORT.WIDTH;
-    const maxY = viewport ? viewport.height : DEFAULT_VIEWPORT.HEIGHT;
+    // Use cached viewport for better performance
+    const viewport = await getCachedViewport(page);
+    const maxX = viewport.width;
+    const maxY = viewport.height;
 
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       try {
@@ -638,6 +670,33 @@ async function simulateTyping(page, text, options = {}) {
   }
 }
 
+/**
+ * Cleans up interaction-related memory and cached data
+ * Should be called periodically in long-running sessions
+ * 
+ * @param {boolean} force - Force cleanup regardless of timing
+ */
+function cleanupInteractionMemory(force = false) {
+  interactionMemoryCleanupCounter++;
+  
+  // Only cleanup every 10 calls unless forced
+  if (!force && interactionMemoryCleanupCounter % 10 !== 0) {
+    return;
+  }
+  
+  // Clear cached viewport if it's older than cache duration
+  const now = Date.now();
+  if (cachedViewport && (now - lastViewportCheck) > VIEWPORT_CACHE_DURATION) {
+    cachedViewport = null;
+    lastViewportCheck = 0;
+  }
+  
+  // Force garbage collection if available (helps with memory pressure)
+  if (global.gc) {
+    global.gc();
+  }
+}
+
 /**
  * Performs comprehensive page interaction simulation - MAIN ENTRY POINT
  * 
@@ -711,10 +770,9 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
   try {
     // Validate page state before starting interaction
     try {
-      // Use site-specific timeout based on configuration
-      // Sites with longer configured timeouts get more time for body detection
-      const siteTimeout = options.siteTimeout || 30000; // From site config
-      const bodyTimeout = Math.min(Math.max(siteTimeout / 6, 3000), 8000); // 3-8 seconds
+      // Optimized timeout calculation - shorter for better performance
+      const siteTimeout = options.siteTimeout || 20000; // Reduced default
+      const bodyTimeout = Math.min(Math.max(siteTimeout / 8, 2000), 5000); // 2-5 seconds (reduced)
       
       await page.waitForSelector('body', { timeout: bodyTimeout });
       
@@ -735,9 +793,9 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
       }
     } catch (bodyCheckErr) {
       if (forceDebug) {
-        console.log(`[interaction] Page not ready for interaction on ${currentUrl} (waited ${bodyTimeout}ms): ${bodyCheckErr.message}`);
+        console.log(`[interaction] Page not ready for interaction on ${currentUrl} (waited ${Math.min(Math.max((options.siteTimeout || 20000) / 8, 2000), 5000)}ms): ${bodyCheckErr.message}`);
         // For very slow sites, we might want to try a minimal interaction anyway
-        if (bodyTimeout >= 6000 && !bodyCheckErr.message.includes('closed')) {
+        if (Math.min(Math.max((options.siteTimeout || 20000) / 8, 2000), 5000) >= 4000 && !bodyCheckErr.message.includes('closed')) {
           console.log(`[interaction] Attempting minimal mouse movement only for slow-loading ${currentUrl}`);
           return await performMinimalInteraction(page, currentUrl, options, forceDebug);
         }
@@ -745,10 +803,10 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
       return;
     }
 
-    // Get viewport dimensions
-    const viewport = await page.viewport();
-    const maxX = viewport ? viewport.width : DEFAULT_VIEWPORT.WIDTH;
-    const maxY = viewport ? viewport.height : DEFAULT_VIEWPORT.HEIGHT;
+    // Use cached viewport for better performance
+    const viewport = await getCachedViewport(page);
+    const maxX = viewport.width;
+    const maxY = viewport.height;
 
     if (forceDebug) {
       console.log(`[interaction] Starting enhanced interaction simulation for ${new URL(currentUrl).hostname} (${intensity} intensity)`);
@@ -760,7 +818,13 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
     
     // Start with random position
     let currentPos = generateRandomCoordinates(maxX, maxY, { preferEdges: true });
+    
+    // Batch mouse move operations for better performance
+    try {
     await page.mouse.move(currentPos.x, currentPos.y);
+    } catch (mouseMoveErr) {
+      return; // Exit gracefully if mouse operations fail
+    }
 
     const startTime = Date.now();
     const totalDuration = duration * settings.pauseMultiplier;
@@ -812,6 +876,9 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
       });
     }
 
+    // Periodic memory cleanup during interaction
+    cleanupInteractionMemory();
+
     // Final hover position
     const finalPos = generateRandomCoordinates(maxX, maxY);
     await humanLikeMouseMove(page, currentPos.x, currentPos.y, finalPos.x, finalPos.y);
@@ -847,9 +914,9 @@ async function performMinimalInteraction(page, currentUrl, options = {}, forceDe
   try {
     if (page.isClosed()) return;
     
-    const viewport = await page.viewport();
-    const maxX = viewport ? viewport.width : DEFAULT_VIEWPORT.WIDTH;
-    const maxY = viewport ? viewport.height : DEFAULT_VIEWPORT.HEIGHT;
+    const viewport = await getCachedViewport(page);
+    const maxX = viewport.width;
+    const maxY = viewport.height;
     
     if (forceDebug) {
       console.log(`[interaction] Performing minimal interaction for slow page: ${new URL(currentUrl).hostname}`);
@@ -860,7 +927,7 @@ async function performMinimalInteraction(page, currentUrl, options = {}, forceDe
     const endPos = generateRandomCoordinates(maxX, maxY);
     
     await page.mouse.move(startPos.x, startPos.y);
-    await fastTimeout(500);
+    await fastTimeout(200);
     await humanLikeMouseMove(page, startPos.x, startPos.y, endPos.x, endPos.y);
     
   } catch (minimalErr) {
@@ -1016,7 +1083,8 @@ module.exports = {
   // Main interaction functions
   performPageInteraction,
   createInteractionConfig,
-  
+  getCachedViewport,
+  cleanupInteractionMemory,
   // Component functions for custom implementations
   humanLikeMouseMove,
   simulateScrolling,

package/nwss.js

@@ -1,4 +1,4 @@
-// === Network scanner script (nwss.js) v1.0.65 ===
+// === Network scanner script (nwss.js) v1.0.67 ===
 
 // puppeteer for browser automation, fs for file system operations, psl for domain parsing.
 // const pLimit = require('p-limit'); // Will be dynamically imported
@@ -85,7 +85,7 @@ const { navigateWithRedirectHandling, handleRedirectTimeout } = require('./lib/r
 const { monitorBrowserHealth, isBrowserHealthy } = require('./lib/browserhealth');
 
 // --- Script Configuration & Constants --- 
-const VERSION = '1.0.65'; // Script version
+const VERSION = '1.0.67'; // Script version
 
 // get startTime
 const startTime = Date.now();
@@ -1837,10 +1837,14 @@ function setupFrameHandling(page, forceDebug) {
       page.on('request', request => {
         const checkedUrl = request.url();
         const checkedHostname = safeGetDomain(checkedUrl, true);
+        const checkedRootDomain = safeGetDomain(checkedUrl, false); // Root domain for first-party detection
         // Use effectiveCurrentUrl which gets updated after redirects
         // This ensures first-party detection uses the final redirected domain
         const effectiveCurrentHostname = safeGetDomain(effectiveCurrentUrl, true);
-      const isFirstParty = checkedHostname && effectiveCurrentHostname && checkedHostname === effectiveCurrentHostname;
+        const effectiveCurrentRootDomain = safeGetDomain(effectiveCurrentUrl, false); // Root domain for comparison
+        
+        // FIXED: Compare root domains instead of full hostnames for first-party detection
+        const isFirstParty = checkedRootDomain && effectiveCurrentRootDomain && checkedRootDomain === effectiveCurrentRootDomain;
         
         // Block infinite iframe loops
         const frameUrl = request.frame() ? request.frame().url() : '';

package/package.json

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