@fanboynz/network-scanner 2.0.57 → 2.0.59

package/lib/compress.js

@@ -24,9 +24,7 @@ async function compressFile(filePath, removeOriginal = true) {
     const handleError = (error) => {
       // Clean up partial compressed file on error
       try {
-        if (fs.existsSync(compressedPath)) {
-          fs.unlinkSync(compressedPath);
-        }
+        fs.unlinkSync(compressedPath);
       } catch (cleanupErr) {
         // Ignore cleanup errors
       }
@@ -69,18 +67,11 @@ async function compressMultipleFiles(filePaths, removeOriginals = true) {
   
   for (const filePath of filePaths) {
     try {
-      if (fs.existsSync(filePath)) {
-        const compressedPath = await compressFile(filePath, removeOriginals);
-        results.successful.push({
-          original: filePath,
-          compressed: compressedPath
-        });
-      } else {
-        results.failed.push({
-          path: filePath,
-          error: 'File does not exist'
-        });
-      }
+      const compressedPath = await compressFile(filePath, removeOriginals);
+      results.successful.push({
+        original: filePath,
+        compressed: compressedPath
+      });
     } catch (error) {
       results.failed.push({
         path: filePath,

package/lib/dry-run.js

@@ -436,7 +436,7 @@ function writeDryRunOutput(outputFile, dryRunOutput, silentMode = false) {
     // Ensure output directory exists
     const path = require('path');
     const outputDir = path.dirname(outputFile);
-    if (outputDir !== '.' && !fs.existsSync(outputDir)) {
+    if (outputDir !== '.') {
       fs.mkdirSync(outputDir, { recursive: true });
     }
     

package/lib/fingerprint.js

@@ -41,8 +41,6 @@ const USER_AGENT_COLLECTIONS = Object.freeze(new Map([
   ['safari', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15"]
 ]));
 
-// Timezone configuration with offsets
-
 // GPU pool — realistic vendor/renderer combos per OS (used for WebGL spoofing)
 const GPU_POOL = {
   windows: [
@@ -86,12 +84,20 @@ function selectGpuForUserAgent(userAgentString) {
   const pool = GPU_POOL[osKey];
   return pool[Math.floor(Math.random() * pool.length)];
 }
-const TIMEZONE_CONFIG = {
-  'America/New_York': { offset: 300, abbr: 'EST' },
-  'America/Los_Angeles': { offset: 480, abbr: 'PST' },
-  'Europe/London': { offset: 0, abbr: 'GMT' },
-  'America/Chicago': { offset: 360, abbr: 'CST' }
-};
+
+/**
+ * Checks if an error is a session/protocol closed error (common during page navigation)
+ */
+function isSessionClosedError(err) {
+  const msg = err.message;
+  return msg.includes('Session closed') ||
+    msg.includes('addScriptToEvaluateOnNewDocument timed out') ||
+    msg.includes('Target closed') ||
+    msg.includes('Protocol error') || err.name === 'ProtocolError' ||
+    msg.includes('detached Frame') || msg.includes('Navigating frame was detached') ||
+    msg.includes('Cannot find context') ||
+    msg.includes('Execution context was destroyed');
+}
 
 /**
  * Safely defines a property with comprehensive error handling
@@ -406,11 +412,6 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           }
         }
 
-        // Add cached descriptors helper for page context
-        const CACHED_DESCRIPTORS = {
-          getter: (fn) => ({ get: fn, enumerable: true, configurable: true })
-        };
-        
         // Add monomorphic spoofing functions for page context
         function spoofNavigatorProperties(navigator, properties) {
           for (const [prop, descriptor] of Object.entries(properties)) {
@@ -1689,15 +1690,31 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           if (debugEnabled) console.log('[fingerprint] toString protection applied to all spoofed functions');
         }, 'Function.prototype.toString bulk masking');
 
+        // Trigger interaction-gated scripts (GTM, Monetag etc.) on page load
+        safeExecute(() => {
+          function triggerInteraction() {
+            setTimeout(() => {
+              const x = Math.floor(Math.random() * 800) + 100;
+              const y = Math.floor(Math.random() * 400) + 100;
+              window.dispatchEvent(new MouseEvent('mousemove', {
+                clientX: x, clientY: y, pageX: x, pageY: y, bubbles: true, cancelable: true, view: window
+              }));
+              window.dispatchEvent(new Event('scroll', { bubbles: true }));
+              document.dispatchEvent(new KeyboardEvent('keydown', {
+                key: 'Tab', code: 'Tab', bubbles: true
+              }));
+            }, 50);
+          }
+          if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', triggerInteraction, { once: true });
+          } else {
+            triggerInteraction();
+          }
+        }, 'interaction-gated script trigger');
+
       }, ua, forceDebug, selectedGpu);
     } catch (stealthErr) {
-      if (stealthErr.message.includes('Session closed') || 
-          stealthErr.message.includes('addScriptToEvaluateOnNewDocument timed out') ||
-          stealthErr.message.includes('Target closed') ||
-          stealthErr.message.includes('Protocol error') || stealthErr.name === 'ProtocolError' ||
-          stealthErr.message.includes('detached Frame') || stealthErr.message.includes('Navigating frame was detached') ||
-          stealthErr.message.includes('Cannot find context') ||
-          stealthErr.message.includes('Execution context was destroyed')) {
+      if (isSessionClosedError(stealthErr)) {
         if (forceDebug) console.log(`[debug] Page closed during stealth injection: ${currentUrl}`);
         return;
       }
@@ -1749,13 +1766,7 @@ async function applyBraveSpoofing(page, siteConfig, forceDebug, currentUrl) {
     }
     }, forceDebug);
   } catch (braveErr) {
-    if (braveErr.message.includes('Session closed') || 
-        braveErr.message.includes('addScriptToEvaluateOnNewDocument timed out') ||
-        braveErr.message.includes('Target closed') ||
-        braveErr.message.includes('Protocol error') || braveErr.name === 'ProtocolError' ||
-        braveErr.message.includes('detached Frame') || braveErr.message.includes('Navigating frame was detached') ||
-        braveErr.message.includes('Cannot find context') ||
-        braveErr.message.includes('Execution context was destroyed')) {
+    if (isSessionClosedError(braveErr)) {
       if (forceDebug) console.log(`[debug] Page closed during Brave injection: ${currentUrl}`);
       return;
     }
@@ -1918,13 +1929,7 @@ async function applyFingerprintProtection(page, siteConfig, forceDebug, currentU
       
     }, { spoof, debugEnabled: forceDebug });
   } catch (err) {
-    if (err.message.includes('Session closed') || 
-        err.message.includes('addScriptToEvaluateOnNewDocument timed out') ||
-        err.message.includes('Target closed') ||
-        err.message.includes('Protocol error') || err.name === 'ProtocolError' ||
-        err.message.includes('detached Frame') || err.message.includes('Navigating frame was detached') ||
-        err.message.includes('Cannot find context') ||
-        err.message.includes('Execution context was destroyed')) {
+    if (isSessionClosedError(err)) {
       if (forceDebug) console.log(`[debug] Page closed during fingerprint injection: ${currentUrl}`);
       return;
     }
@@ -2008,6 +2013,10 @@ async function simulateHumanBehavior(page, forceDebug) {
             document.dispatchEvent(new MouseEvent('mousemove', {
               clientX: mouseX,
               clientY: mouseY,
+              pageX: mouseX + (window.scrollX || 0),
+              pageY: mouseY + (window.scrollY || 0),
+              screenX: mouseX + (window.screenX || 0),
+              screenY: mouseY + (window.screenY || 0),
               bubbles: true,
               cancelable: true,
               view: window,
@@ -2021,6 +2030,10 @@ async function simulateHumanBehavior(page, forceDebug) {
               document.dispatchEvent(new MouseEvent('click', {
                 clientX: mouseX,
                 clientY: mouseY,
+                pageX: mouseX + (window.scrollX || 0),
+                pageY: mouseY + (window.scrollY || 0),
+                screenX: mouseX + (window.screenX || 0),
+                screenY: mouseY + (window.screenY || 0),
                 bubbles: true,
                 cancelable: true,
                 view: window
@@ -2083,9 +2096,6 @@ async function applyAllFingerprintSpoofing(page, siteConfig, forceDebug, current
   }
 }
 
-// Legacy compatibility function - maintained for backwards compatibility
-
-
 module.exports = {
   generateRealisticFingerprint,
   getRealisticScreenResolution,

package/lib/flowproxy.js

@@ -41,6 +41,13 @@ const FAST_TIMEOUTS = {
  * Gets module version information
  * @returns {object} Version information object
  */
+// Protocols to skip — FlowProxy only protects web traffic
+const SKIP_PATTERNS = [
+  'about:', 'chrome:', 'chrome-extension:', 'chrome-error:', 'chrome-search:',
+  'devtools:', 'edge:', 'moz-extension:', 'safari-extension:', 'webkit:',
+  'data:', 'blob:', 'javascript:', 'vbscript:', 'file:', 'ftp:', 'ftps:'
+];
+
 function getModuleInfo() {
   return {
     version: FLOWPROXY_MODULE_VERSION,
@@ -73,15 +80,8 @@ function shouldProcessUrl(url, forceDebug = false) {
   }
 
   // Skip browser-internal and special protocol URLs
-  // These protocols are not relevant for FlowProxy protection
-  const skipPatterns = [
-    'about:', 'chrome:', 'chrome-extension:', 'chrome-error:', 'chrome-search:',
-    'devtools:', 'edge:', 'moz-extension:', 'safari-extension:', 'webkit:',
-    'data:', 'blob:', 'javascript:', 'vbscript:', 'file:', 'ftp:', 'ftps:'
-  ];
-
   const urlLower = url.toLowerCase();
-  for (const pattern of skipPatterns) {
+  for (const pattern of SKIP_PATTERNS) {
     if (urlLower.startsWith(pattern)) {
       if (forceDebug) {
         console.log(`[flowproxy][url-validation] Skipping ${pattern} URL: ${url.substring(0, 100)}${url.length > 100 ? '...' : ''}`);

package/lib/ghost-cursor.js

@@ -0,0 +1,258 @@
+// === Ghost Cursor Module ===
+// Optional wrapper around the ghost-cursor npm package for advanced Bezier-based mouse movements.
+// Falls back gracefully to built-in interaction.js mouse if ghost-cursor is not installed.
+//
+// USAGE (JSON config):
+//   "cursor_mode": "ghost"              Enable ghost-cursor for this site
+//   "ghost_cursor_speed": 1.5           Movement speed multiplier (default: 1.0)
+//   "ghost_cursor_hesitate": 100        Delay (ms) before clicking (default: 50)
+//   "ghost_cursor_overshoot": 500       Max overshoot distance in px (default: auto)
+//
+// USAGE (CLI):
+//   --ghost-cursor                      Enable ghost-cursor globally
+//
+// INSTALL:
+//   npm install ghost-cursor            (optional dependency)
+
+const { formatLogMessage } = require('./colorize');
+
+let ghostCursorModule = null;
+let ghostCursorAvailable = false;
+
+// Attempt to load ghost-cursor at module init — optional dependency
+try {
+  ghostCursorModule = require('ghost-cursor');
+  ghostCursorAvailable = true;
+} catch {
+  // ghost-cursor not installed — this is fine, built-in mouse will be used
+}
+
+/**
+ * Check if ghost-cursor is available
+ * @returns {boolean}
+ */
+function isGhostCursorAvailable() {
+  return ghostCursorAvailable;
+}
+
+/**
+ * Create a ghost-cursor instance bound to a Puppeteer page
+ * @param {import('puppeteer').Page} page - Puppeteer page instance
+ * @param {object} options - Configuration options
+ * @param {boolean} options.forceDebug - Enable debug logging
+ * @param {number} options.startX - Starting X coordinate (default: 0)
+ * @param {number} options.startY - Starting Y coordinate (default: 0)
+ * @returns {object|null} Ghost cursor instance or null if unavailable
+ */
+function createGhostCursor(page, options = {}) {
+  if (!ghostCursorAvailable) {
+    return null;
+  }
+
+  const { forceDebug, startX = 0, startY = 0 } = options;
+
+  try {
+    const cursor = ghostCursorModule.createCursor(page, { x: startX, y: startY });
+
+    if (forceDebug) {
+      console.log(formatLogMessage('debug', '[ghost-cursor] Cursor instance created'));
+    }
+
+    return cursor;
+  } catch (err) {
+    if (forceDebug) {
+      console.log(formatLogMessage('debug', `[ghost-cursor] Failed to create cursor: ${err.message}`));
+    }
+    return null;
+  }
+}
+
+/**
+ * Move cursor to coordinates using ghost-cursor Bezier paths
+ * Drop-in replacement for humanLikeMouseMove when ghost-cursor is active
+ *
+ * @param {object} cursor - Ghost cursor instance from createGhostCursor()
+ * @param {number} toX - Target X coordinate
+ * @param {number} toY - Target Y coordinate
+ * @param {object} options - Movement options
+ * @param {number} options.moveSpeed - Speed multiplier (default: auto/random)
+ * @param {number} options.moveDelay - Delay after movement in ms (default: 0)
+ * @param {boolean} options.randomizeMoveDelay - Randomize move delay (default: true)
+ * @param {number} options.overshootThreshold - Max overshoot distance in px
+ * @param {boolean} options.forceDebug - Enable debug logging
+ * @returns {Promise<boolean>} true if movement succeeded
+ */
+async function ghostMove(cursor, toX, toY, options = {}) {
+  if (!cursor) return false;
+
+  const {
+    moveSpeed,
+    moveDelay = 0,
+    randomizeMoveDelay = true,
+    overshootThreshold,
+    forceDebug
+  } = options;
+
+  try {
+    const moveOpts = {};
+    if (moveSpeed !== undefined) moveOpts.moveSpeed = moveSpeed;
+    if (moveDelay > 0) moveOpts.moveDelay = moveDelay;
+    if (randomizeMoveDelay !== undefined) moveOpts.randomizeMoveDelay = randomizeMoveDelay;
+    if (overshootThreshold !== undefined) moveOpts.overshootThreshold = overshootThreshold;
+
+    await cursor.moveTo({ x: toX, y: toY }, moveOpts);
+
+    if (forceDebug) {
+      console.log(formatLogMessage('debug', `[ghost-cursor] Moved to (${Math.round(toX)}, ${Math.round(toY)})`));
+    }
+
+    return true;
+  } catch (err) {
+    if (forceDebug) {
+      console.log(formatLogMessage('debug', `[ghost-cursor] Move failed: ${err.message}`));
+    }
+    return false;
+  }
+}
+
+/**
+ * Click on a CSS selector or coordinates using ghost-cursor
+ *
+ * @param {object} cursor - Ghost cursor instance
+ * @param {string|{x: number, y: number}} target - CSS selector or {x, y} coordinates
+ * @param {object} options - Click options
+ * @param {number} options.hesitate - Delay (ms) before clicking (default: 50)
+ * @param {number} options.waitForClick - Delay (ms) between mousedown/mouseup (default: auto)
+ * @param {number} options.moveDelay - Delay (ms) after moving to target
+ * @param {number} options.paddingPercentage - Click point within element (0=edge, 100=center)
+ * @param {boolean} options.forceDebug - Enable debug logging
+ * @returns {Promise<boolean>} true if click succeeded
+ */
+async function ghostClick(cursor, target, options = {}) {
+  if (!cursor) return false;
+
+  const {
+    hesitate = 50,
+    waitForClick,
+    moveDelay,
+    paddingPercentage,
+    forceDebug
+  } = options;
+
+  try {
+    const clickOpts = { hesitate };
+    if (waitForClick !== undefined) clickOpts.waitForClick = waitForClick;
+    if (moveDelay !== undefined) clickOpts.moveDelay = moveDelay;
+    if (paddingPercentage !== undefined) clickOpts.paddingPercentage = paddingPercentage;
+
+    if (typeof target === 'string') {
+      await cursor.click(target, clickOpts);
+    } else {
+      // For coordinate clicks, move first then use page click
+      await cursor.moveTo(target);
+      // Small hesitation before clicking
+      if (hesitate > 0) {
+        await new Promise(resolve => setTimeout(resolve, hesitate));
+      }
+      const page = cursor._page || cursor.page;
+      if (page && typeof page.mouse?.click === 'function') {
+        await page.mouse.click(target.x, target.y);
+      }
+    }
+
+    if (forceDebug) {
+      const label = typeof target === 'string' ? target : `(${Math.round(target.x)}, ${Math.round(target.y)})`;
+      console.log(formatLogMessage('debug', `[ghost-cursor] Clicked ${label}`));
+    }
+
+    return true;
+  } catch (err) {
+    if (forceDebug) {
+      console.log(formatLogMessage('debug', `[ghost-cursor] Click failed: ${err.message}`));
+    }
+    return false;
+  }
+}
+
+/**
+ * Perform a random idle mouse movement using ghost-cursor
+ *
+ * @param {object} cursor - Ghost cursor instance
+ * @param {object} options - Options
+ * @param {boolean} options.forceDebug - Enable debug logging
+ * @returns {Promise<boolean>} true if movement succeeded
+ */
+async function ghostRandomMove(cursor, options = {}) {
+  if (!cursor) return false;
+
+  try {
+    await cursor.randomMove();
+    if (options.forceDebug) {
+      console.log(formatLogMessage('debug', '[ghost-cursor] Random movement performed'));
+    }
+    return true;
+  } catch (err) {
+    if (options.forceDebug) {
+      console.log(formatLogMessage('debug', `[ghost-cursor] Random move failed: ${err.message}`));
+    }
+    return false;
+  }
+}
+
+/**
+ * Generate a Bezier path between two points (standalone, no browser needed)
+ *
+ * @param {{x: number, y: number}} from - Start point
+ * @param {{x: number, y: number}} to - End point
+ * @param {object} options - Path options
+ * @param {number} options.spreadOverride - Override curve spread
+ * @param {number} options.moveSpeed - Movement speed
+ * @returns {Array<{x: number, y: number}>|null} Array of path points or null
+ */
+function ghostPath(from, to, options = {}) {
+  if (!ghostCursorAvailable || !ghostCursorModule.path) return null;
+
+  try {
+    return ghostCursorModule.path(from, to, options);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve ghost-cursor settings from site config and CLI flags.
+ * Returns null if ghost-cursor should not be used.
+ *
+ * @param {object} siteConfig - Per-site JSON configuration
+ * @param {boolean} globalGhostCursor - CLI --ghost-cursor flag
+ * @param {boolean} forceDebug - Debug logging flag
+ * @returns {object|null} Resolved ghost-cursor options or null
+ */
+function resolveGhostCursorConfig(siteConfig, globalGhostCursor, forceDebug) {
+  const enabled = globalGhostCursor || siteConfig.cursor_mode === 'ghost';
+
+  if (!enabled) return null;
+
+  if (!ghostCursorAvailable) {
+    console.warn(formatLogMessage('warn', '[ghost-cursor] cursor_mode "ghost" requested but ghost-cursor package is not installed. Run: npm install ghost-cursor'));
+    return null;
+  }
+
+  return {
+    moveSpeed: siteConfig.ghost_cursor_speed || undefined,
+    hesitate: siteConfig.ghost_cursor_hesitate ?? 50,
+    overshootThreshold: siteConfig.ghost_cursor_overshoot || undefined,
+    duration: siteConfig.ghost_cursor_duration || siteConfig.interact_duration || 2000,
+    forceDebug
+  };
+}
+
+module.exports = {
+  isGhostCursorAvailable,
+  createGhostCursor,
+  ghostMove,
+  ghostClick,
+  ghostRandomMove,
+  ghostPath,
+  resolveGhostCursorConfig
+};

package/lib/grep.js

@@ -28,7 +28,7 @@ const GREP_DEFAULTS = {
  * @param {object} options - Grep options
  * @returns {Promise<object>} Object with found boolean, matchedPattern, and allMatches array
  */
-async function grepContent(content, searchPatterns, options = {}) {
+function grepContent(content, searchPatterns, options = {}) {
   const {
     ignoreCase = true,
     wholeWord = false,

package/lib/interaction.js

@@ -374,11 +374,14 @@ async function humanLikeMouseMove(page, fromX, fromY, toX, toY, options = {}) {
   }
 
   for (let i = 0; i <= actualSteps; i++) {
+    // Bail out if page closed mid-movement
+    try { if (page.isClosed()) return; } catch { return; }
+
     const progress = i / actualSteps;
-    
+
     // Apply easing curve for more natural movement
-    const easedProgress = progress < 0.5 
-      ? 2 * progress * progress 
+    const easedProgress = progress < 0.5
+      ? 2 * progress * progress
       : 1 - Math.pow(-2 * progress + 2, 2) / 2;
 
     // Calculate base position
@@ -390,7 +393,7 @@ async function humanLikeMouseMove(page, fromX, fromY, toX, toY, options = {}) {
       const curveIntensity = Math.sin((i / actualSteps) * Math.PI) * curve * distance * MOUSE_MOVEMENT.CURVE_INTENSITY_RATIO;
       const perpX = -(toY - fromY) / distance;
       const perpY = (toX - fromX) / distance;
-      
+
       currentX += perpX * curveIntensity;
       currentY += perpY * curveIntensity;
     }
@@ -402,7 +405,7 @@ async function humanLikeMouseMove(page, fromX, fromY, toX, toY, options = {}) {
     }
 
     await page.mouse.move(currentX, currentY);
-    
+
     // Variable delay between movements
     if (i < actualSteps) {
       const delay = Math.floor(Math.random() * (maxDelay - minDelay + 1)) + minDelay;
@@ -457,14 +460,16 @@ async function simulateScrolling(page, options = {}) {
 
   try {
     for (let i = 0; i < amount; i++) {
+      try { if (page.isClosed()) return; } catch { return; }
+
       const scrollDelta = direction === 'down' ? SCROLLING.SCROLL_DELTA : -SCROLLING.SCROLL_DELTA;
-      
+
       // Smooth scrolling by breaking into smaller increments
       for (let j = 0; j < smoothness; j++) {
         await page.mouse.wheel({ deltaY: scrollDelta / smoothness });
         await fastTimeout(SCROLLING.SMOOTH_INCREMENT_DELAY);
       }
-      
+
       if (i < amount - 1) {
         await fastTimeout(pauseBetween);
       }
@@ -547,6 +552,8 @@ async function interactWithElements(page, options = {}) {
 
       // Very short timeout since page should already be loaded
       await page.waitForSelector('body', { timeout: 1000 });
+      // Re-check after async wait — page may have closed during selector wait
+      if (page.isClosed()) return;
     } catch (bodyWaitErr) {
       if (options.forceDebug) {
         console.log(`[interaction] Page not ready for element interaction: ${bodyWaitErr.message}`);
@@ -677,7 +684,7 @@ async function performContentClicks(page, options = {}) {
     let lastY = minY + Math.floor(Math.random() * (maxY - minY));
 
     for (let i = 0; i < clicks; i++) {
-      if (page.isClosed()) break;
+      try { if (page.isClosed()) break; } catch { break; }
 
       // Random position in content zone
       const targetX = minX + Math.floor(Math.random() * (maxX - minX));
@@ -813,11 +820,6 @@ function cleanupInteractionMemory(force = false) {
     cachedViewport = null;
     lastViewportCheck = 0;
   }
-  
-  // Force garbage collection if available (helps with memory pressure)
-  if (global.gc) {
-    global.gc();
-  }
 }
 
 /**
@@ -915,7 +917,9 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
     const maxY = viewport.height;
 
     if (forceDebug) {
-      console.log(`[interaction] Starting enhanced interaction simulation for ${new URL(currentUrl).hostname} (${intensity} intensity)`);
+      let hostname = currentUrl;
+      try { hostname = new URL(currentUrl).hostname; } catch {}
+      console.log(`[interaction] Starting enhanced interaction simulation for ${hostname} (${intensity} intensity)`);
     }
 
     // Configure intensity settings
@@ -1010,8 +1014,11 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
     try {
       const bodyElement = await page.$('body');
       if (bodyElement) {
-        await page.hover('body');
-        await bodyElement.dispose();
+        try {
+          await page.hover('body');
+        } finally {
+          await bodyElement.dispose();
+        }
       }
     } catch (hoverErr) {
       // Silently handle hover failures - not critical
@@ -1037,35 +1044,6 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
   }
 }
 
-/**
- * Performs minimal interaction for very slow or problematic pages
- * Only does basic mouse movement without body validation
- */
-async function performMinimalInteraction(page, currentUrl, options = {}, forceDebug = false) {
-  try {
-    if (page.isClosed()) return;
-    
-    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}`);
-    }
-    
-    // Just do basic mouse movement without body-dependent operations
-    const startPos = generateRandomCoordinates(maxX, maxY);
-    const endPos = generateRandomCoordinates(maxX, maxY);
-    
-    await page.mouse.move(startPos.x, startPos.y);
-    await fastTimeout(200);
-    await humanLikeMouseMove(page, startPos.x, startPos.y, endPos.x, endPos.y);
-    
-  } catch (minimalErr) {
-    // Even minimal interaction failed - page is truly broken
-  }
-}
-
 /**
  * Creates an optimized interaction configuration based on site characteristics
  *