@fanboynz/network-scanner 2.0.58 → 2.0.60

package/lib/cdp.js

@@ -28,15 +28,19 @@
 const { formatLogMessage } = require('./colorize');
 
 /**
- * Creates a reusable timeout promise to reduce function allocation overhead
+ * Race a promise against a timeout, clearing the timer when the promise settles.
+ * Prevents leaked setTimeout handles that hold closure references until they fire.
+ * @param {Promise} promise - The operation to race
  * @param {number} ms - Timeout in milliseconds
  * @param {string} message - Error message for timeout
- * @returns {Promise} Promise that rejects after timeout
+ * @returns {Promise} Resolves/rejects with the operation result, or rejects on timeout
  */
-function createTimeoutPromise(ms, message) {
-  return new Promise((_, reject) => 
-    setTimeout(() => reject(new Error(message)), ms)
-  );
+function raceWithTimeout(promise, ms, message) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error(message)), ms);
+  });
+  return Promise.race([promise, timeoutPromise]).finally(() => clearTimeout(timeoutId));
 }
 
 /**
@@ -59,10 +63,7 @@ const createSessionResult = (session = null, cleanup = async () => {}, isEnhance
  * @returns {Promise<import('puppeteer').Page>} Page instance
  */
 async function createPageWithTimeout(browser, timeout = 30000) {
-  return Promise.race([
-    browser.newPage(),
-    createTimeoutPromise(timeout, 'Page creation timeout - browser may be unresponsive')
-  ]);
+  return raceWithTimeout(browser.newPage(), timeout, 'Page creation timeout - browser may be unresponsive');
 }
 
 /**
@@ -73,24 +74,18 @@ async function createPageWithTimeout(browser, timeout = 30000) {
  */
 async function setRequestInterceptionWithTimeout(page, timeout = 15000) {
   try {
-    await Promise.race([
-      page.setRequestInterception(true),
-      createTimeoutPromise(timeout, 'Request interception timeout - first attempt')
-    ]);
+    await raceWithTimeout(page.setRequestInterception(true), timeout, 'Request interception timeout - first attempt');
   } catch (firstError) {
     // Check for immediate critical failures
-    if (firstError.message.includes('Target closed') || 
+    if (firstError.message.includes('Target closed') ||
         firstError.message.includes('Session closed') ||
         firstError.message.includes('Browser has been closed')) {
       throw new Error('CRITICAL_BROWSER_ERROR: ' + firstError.message);
     }
-    
+
     // Retry with extended timeout
     try {
-      await Promise.race([
-        page.setRequestInterception(true),
-        createTimeoutPromise(timeout * 2, 'Request interception timeout - retry failed')
-      ]);
+      await raceWithTimeout(page.setRequestInterception(true), timeout * 2, 'Request interception timeout - retry failed');
     } catch (retryError) {
       if (retryError.message.includes('Network.enable timed out') || 
           retryError.message.includes('ProtocolError')) {
@@ -168,10 +163,7 @@ async function createCDPSession(page, currentUrl, options = {}) {
   try {
     // Create CDP session using modern Puppeteer 20+ API
     // Add timeout protection for CDP session creation
-    cdpSession = await Promise.race([
-      page.createCDPSession(),
-      createTimeoutPromise(20000, 'CDP session creation timeout')
-    ]);
+    cdpSession = await raceWithTimeout(page.createCDPSession(), 20000, 'CDP session creation timeout');
     
     // Enable network domain - required for network event monitoring  
     await cdpSession.send('Network.enable');
@@ -255,150 +247,6 @@ async function createCDPSession(page, currentUrl, options = {}) {
   }
 }
 
-/**
- * Validates CDP availability and configuration
- * 
- * USAGE IN YOUR APPLICATION:
- *   const validation = validateCDPConfig(siteConfig, globalCDPFlag);
- *   if (!validation.isValid) {
- *     console.warn('CDP configuration issues detected');
- *   }
- *   validation.recommendations.forEach(rec => console.log('Recommendation:', rec));
- *
- * @param {object} siteConfig - Site configuration object
- * @param {boolean} globalCDP - Global CDP flag
- * @param {Array} cdpSpecificDomains - Array of domains for cdp_specific feature
- * @returns {object} Validation result with recommendations
- */
-function validateCDPConfig(siteConfig, globalCDP, cdpSpecificDomains = []) {
-  const warnings = [];
-  const recommendations = [];
-  
-  // Check for conflicting configurations
-  if (globalCDP && siteConfig.cdp === false) {
-    warnings.push('Site-specific CDP disabled but global CDP is enabled - global setting will override');
-  }
-  
-  // Validate cdp_specific configuration
-  if (siteConfig.cdp_specific) {
-    if (!Array.isArray(siteConfig.cdp_specific)) {
-      warnings.push('cdp_specific must be an array of domain strings');
-    } else if (siteConfig.cdp_specific.length === 0) {
-      warnings.push('cdp_specific is empty - no domains will have CDP enabled');
-    } else {
-      // Validate domain format
-      const hasInvalidDomains = siteConfig.cdp_specific.some(domain => 
-        typeof domain !== 'string' || domain.trim() === ''
-      );
-      
-      if (hasInvalidDomains) {
-        // Only filter invalid domains if we need to show them
-        const invalidDomains = siteConfig.cdp_specific.filter(domain => 
-          typeof domain !== 'string' || domain.trim() === ''
-        );
-        warnings.push(`cdp_specific contains invalid domains: ${invalidDomains.join(', ')}`);
-      }
-    }
-  }
-  
-  // Performance recommendations
-  const cdpEnabled = globalCDP || siteConfig.cdp === true || 
-    (Array.isArray(siteConfig.cdp_specific) && siteConfig.cdp_specific.length > 0);
-  
-  if (cdpEnabled) {
-    recommendations.push('CDP logging enabled - this may impact performance for high-traffic sites');
-    
-    if (siteConfig.timeout && siteConfig.timeout < 30000) {
-      recommendations.push('Consider increasing timeout when using CDP logging to avoid protocol timeouts');
-    }
-  }
-  
-  return {
-    isValid: true,
-    warnings,
-    recommendations
-  };
-}
-
-/**
- * Enhanced CDP session with additional network monitoring features
- * 
- * ADVANCED FEATURES:
- *   - JavaScript exception monitoring
- *   - Security state change detection  
- *   - Failed network request tracking
- *   - Enhanced error reporting
- *
- * USE CASES:
- *   - Security analysis requiring comprehensive monitoring
- *   - Debugging complex single-page applications
- *   - Performance analysis of web applications
- *   - Research requiring detailed browser insights
- *
- * PERFORMANCE IMPACT:
- *   - Adds additional CDP domain subscriptions
- *   - Higher memory usage due to more event listeners
- *   - Recommended only for detailed analysis scenarios
- *
- * @param {import('puppeteer').Page} page - The Puppeteer page instance
- * @param {string} currentUrl - The URL being processed
- * @param {object} options - Configuration options (same as createCDPSession)
- * @returns {Promise<object>} Enhanced CDP session object with isEnhanced flag
- */
-async function createEnhancedCDPSession(page, currentUrl, options = {}) {
-  const basicSession = await createCDPSession(page, currentUrl, options);
-  
-  if (!basicSession.session) {
-    // Ensure enhanced flag is set even for null sessions
-    return { ...basicSession, isEnhanced: false };
-  }
-
-  const { session } = basicSession;
-  const { forceDebug } = options;
-
-  try {
-    // Enable additional CDP domains for enhanced monitoring
-    await session.send('Runtime.enable');  // For JavaScript exceptions
-    await session.send('Security.enable'); // For security state changes
-    
-    // Monitor JavaScript exceptions - useful for debugging problematic sites
-    session.on('Runtime.exceptionThrown', (params) => {
-      if (forceDebug) {
-        console.log(formatLogMessage('debug', `[cdp][exception] ${params.exceptionDetails.text}`));
-      }
-    });
-
-    // Monitor security state changes - detect mixed content, certificate issues, etc.
-    session.on('Security.securityStateChanged', (params) => {
-      if (forceDebug && params.securityState !== 'secure') {
-        console.log(formatLogMessage('debug', `[cdp][security] Security state: ${params.securityState}`));
-      }
-    });
-
-    // Monitor failed network requests - useful for understanding site issues
-    session.on('Network.loadingFailed', (params) => {
-      if (forceDebug) {
-        console.log(formatLogMessage('debug', `[cdp][failed] ${params.errorText}: ${params.requestId}`));
-      }
-    });
-
-    return {
-      session,
-      cleanup: basicSession.cleanup,
-      isEnhanced: true // Flag to indicate enhanced features are active
-    };
-
-  } catch (enhancedErr) {
-    if (forceDebug) {
-      console.log(formatLogMessage('debug', `Enhanced CDP features failed, falling back to basic session: ${enhancedErr.message}`));
-    }
-    
-    // Graceful degradation: return basic session if enhanced features fail
-    // This ensures your application continues working even if advanced features break
-    return { ...basicSession, isEnhanced: false };
-  }
-}
-
 // EXPORT INTERFACE FOR OTHER APPLICATIONS:
 // This module provides a clean, reusable interface for CDP integration.
 // Simply require this module and use the exported functions.
@@ -406,7 +254,7 @@ async function createEnhancedCDPSession(page, currentUrl, options = {}) {
 // CUSTOMIZATION TIPS:
 // 1. Replace './colorize' import with your own logging system
 // 2. Modify the request logging format in the Network.requestWillBeSent handler
-// 3. Add additional CDP domain subscriptions in createEnhancedCDPSession
+// 3. Add additional CDP domain subscriptions in createCDPSession
 // 4. Customize error categorization in the catch blocks
 //
 // TROUBLESHOOTING:

package/lib/compare.js

@@ -1,6 +1,23 @@
 const fs = require('fs');
 const path = require('path');
 
+// Pre-compiled regexes for rule normalization (shared across functions)
+const RE_ADBLOCK_PREFIX = /^\|\|?/;
+const RE_LOCALHOST_127 = /^127\.0\.0\.1\s+/;
+const RE_LOCALHOST_000 = /^0\.0\.0\.0\s+/;
+const RE_CARET_SUFFIX = /\^.*$/;
+const RE_DOLLAR_SUFFIX = /\$.*$/;
+
+function normalizeRuleInline(rule) {
+  return rule
+    .replace(RE_ADBLOCK_PREFIX, '')
+    .replace(RE_LOCALHOST_127, '')
+    .replace(RE_LOCALHOST_000, '')
+    .replace(RE_CARET_SUFFIX, '')
+    .replace(RE_DOLLAR_SUFFIX, '')
+    .trim();
+}
+
 /**
  * Loads rules from a comparison file and returns them as a Set for fast lookup
  * @param {string} compareFilePath - Path to the file containing existing rules
@@ -17,23 +34,7 @@ function loadComparisonRules(compareFilePath, forceDebug = false) {
     const rules = new Set();
     
     for (const line of lines) {
-      // Normalize the rule by removing different prefixes/formats
-      let normalizedRule = line;
-      
-      // Remove adblock prefixes (||, |, etc.)
-      normalizedRule = normalizedRule.replace(/^\|\|/, '');
-      normalizedRule = normalizedRule.replace(/^\|/, '');
-      
-      // Remove localhost prefixes
-      normalizedRule = normalizedRule.replace(/^127\.0\.0\.1\s+/, '');
-      normalizedRule = normalizedRule.replace(/^0\.0\.0\.0\s+/, '');
-      
-      // Remove adblock suffixes and modifiers
-      normalizedRule = normalizedRule.replace(/\^.*$/, ''); // Remove ^ and everything after
-      normalizedRule = normalizedRule.replace(/\$.*$/, ''); // Remove $ and everything after
-      
-      // Clean up and add to set
-      normalizedRule = normalizedRule.trim();
+      const normalizedRule = normalizeRuleInline(line);
       if (normalizedRule) {
         rules.add(normalizedRule);
       }
@@ -55,21 +56,7 @@ function loadComparisonRules(compareFilePath, forceDebug = false) {
  * @returns {string} Normalized rule
  */
 function normalizeRule(rule) {
-  let normalized = rule;
-  
-  // Remove adblock prefixes
-  normalized = normalized.replace(/^\|\|/, '');
-  normalized = normalized.replace(/^\|/, '');
-  
-  // Remove localhost prefixes
-  normalized = normalized.replace(/^127\.0\.0\.1\s+/, '');
-  normalized = normalized.replace(/^0\.0\.0\.0\s+/, '');
-  
-  // Remove adblock suffixes and modifiers
-  normalized = normalized.replace(/\^.*$/, '');
-  normalized = normalized.replace(/\$.*$/, '');
-  
-  return normalized.trim();
+  return normalizeRuleInline(rule);
 }
 
 /**

package/lib/domain-cache.js

@@ -148,14 +148,16 @@ class DomainCache {
    */
   clearOldestEntries(count) {
     if (count <= 0) return;
-    
-    const entries = Array.from(this.cache);
-    const toRemove = entries.slice(0, count);
-    
-    toRemove.forEach(domain => this.cache.delete(domain));
-    
+
+    let removed = 0;
+    for (const domain of this.cache) {
+      if (removed >= count) break;
+      this.cache.delete(domain);
+      removed++;
+    }
+
     if (this.enableLogging) {
-      console.log(formatLogMessage('debug', `${this.logPrefix} Cleared ${toRemove.length} old entries, cache size now: ${this.cache.size}`));
+      console.log(formatLogMessage('debug', `${this.logPrefix} Cleared ${removed} old entries, cache size now: ${this.cache.size}`));
     }
   }
 

package/lib/fingerprint.js

@@ -1697,7 +1697,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
               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, bubbles: true, cancelable: true, view: window
+                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', {
@@ -2013,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,
@@ -2026,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

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

@@ -41,23 +41,19 @@ function grepContent(content, searchPatterns, options = {}) {
   }
  
   try {
-    
     const allMatches = [];
     let firstMatch = null;
-    
+
+    // Build common args once outside the loop
+    const baseArgs = ['--text', '--color=never'];
+    if (ignoreCase) baseArgs.push('-i');
+    if (wholeWord) baseArgs.push('-w');
+    if (!regex) baseArgs.push('-F');
+
     for (const pattern of searchPatterns) {
       if (!pattern || pattern.trim().length === 0) continue;
-      
-      const grepArgs = [
-        '--text', // Treat file as text
-        '--color=never', // Disable color output
-      ];
-      
-      if (ignoreCase) grepArgs.push('-i');
-      if (wholeWord) grepArgs.push('-w');
-      if (!regex) grepArgs.push('-F'); // Fixed strings (literal)
-      
-      grepArgs.push(pattern);
+
+      const grepArgs = [...baseArgs, pattern];
       
       try {
         const result = spawnSync('grep', grepArgs, {