@fanboynz/network-scanner 2.0.57 → 2.0.59

package/CLAUDE.md

@@ -0,0 +1,65 @@
+# Network Scanner (NWSS)
+
+Puppeteer-based network scanner for analyzing web traffic, generating adblock filter rules, and identifying third-party requests. Features fingerprint spoofing, Cloudflare bypass, content analysis with curl/grep, VPN/proxy routing, and multiple output formats.
+
+## Project Structure
+
+- `nwss.js` — Main entry point (~4,600 lines). CLI args, URL processing, orchestration.
+- `config.json` — Default scan configuration (sites, filters, options).
+- `lib/` — 28 focused, single-purpose modules:
+  - `fingerprint.js` — Bot detection evasion (device/GPU/timezone spoofing)
+  - `cloudflare.js` — Cloudflare challenge detection and solving
+  - `browserhealth.js` — Memory management and browser lifecycle
+  - `interaction.js` — Human-like mouse/scroll/typing simulation
+  - `smart-cache.js` — Multi-layer caching with persistence
+  - `nettools.js` — WHOIS/dig integration
+  - `output.js` — Multi-format rule output (adblock, dnsmasq, unbound, pihole, etc.)
+  - `proxy.js` — SOCKS5/HTTP proxy support
+  - `wireguard_vpn.js` / `openvpn_vpn.js` — VPN routing
+  - `adblock.js` — Adblock filter parsing and validation
+  - `validate_rules.js` — Domain and rule format validation
+  - `colorize.js` — Console output formatting and colors
+  - `domain-cache.js` — Domain detection cache for performance
+  - `post-processing.js` — Result cleanup and deduplication
+  - `redirect.js`, `referrer.js`, `cdp.js`, `curl.js`, `grep.js`, `compare.js`, `compress.js`, `dry-run.js`, `browserexit.js`, `clear_sitedata.js`, `flowproxy.js`, `ignore_similar.js`, `searchstring.js`
+- `.github/workflows/npm-publish.yml` — Automated npm publishing
+- `nwss.1` — Man page
+
+## Tech Stack
+
+- **Node.js** >=20.0.0
+- **puppeteer** >=20.0.0 — Headless browser automation
+- **psl** — Public Suffix List for domain parsing
+- **lru-cache** — LRU cache implementation
+- **p-limit** — Concurrency limiting (dynamically imported)
+- **eslint** — Linting (`npm run lint`)
+
+## Conventions
+
+- Store modular functionality in `./lib/` with focused, single-purpose modules
+- Use `messageColors` and `formatLogMessage` from `./lib/colorize` for consistent console output
+- Implement timeout protection for all Puppeteer operations using `Promise.race` patterns
+- Handle browser lifecycle with comprehensive cleanup in try-finally blocks
+- Validate all external tool availability before use (grep, curl, whois, dig)
+- Use `forceDebug` flag for detailed logging, `silentMode` for minimal output
+- Use `Object.freeze` for constant configuration objects (TIMEOUTS, CACHE_LIMITS, CONCURRENCY_LIMITS)
+- Use `fastTimeout(ms)` helper instead of `node:timers/promises` for Puppeteer 22.x compatibility
+
+## Running
+
+```bash
+node nwss.js                          # Run with default config.json
+node nwss.js config-custom.json       # Run with custom config
+node nwss.js --validate-config        # Validate configuration
+node nwss.js --dry-run                # Preview without network calls
+node nwss.js --headful                # Launch with browser GUI
+```
+
+## Files to Ignore
+
+- `node_modules/**`
+- `logs/**`
+- `sources/**`
+- `.cache/**`
+- `*.log`
+- `*.gz`

package/README.md

@@ -59,8 +59,11 @@ A Puppeteer-based tool for scanning websites to find third-party (or optionally
 | `--compress-logs`           | Compress log files with gzip (requires `--dumpurls`) |
 | `--sub-domains`             | Output full subdomains instead of collapsing to root |
 | `--no-interact`             | Disable page interactions globally |
+| `--ghost-cursor`            | Use ghost-cursor Bezier mouse movements globally (requires `npm i ghost-cursor`) |
 | `--custom-json <file>`      | Use a custom config JSON file instead of config.json |
 | `--headful`                 | Launch browser with GUI (not headless) |
+| `--keep-open`               | Keep browser and tabs open after scan completes (use with `--headful` for debugging) |
+| `--use-puppeteer-core`      | Use `puppeteer-core` with system Chrome instead of bundled Chromium |
 | `--cdp`                     | Enable Chrome DevTools Protocol logging (now per-page if enabled) |
 | `--remove-dupes`            | Remove duplicate domains from output (only with `-o`) |
 | `--dry-run`                 | Console output only: show matching regex, titles, whois/dig/searchstring results, and adblock rules |
@@ -267,6 +270,11 @@ When a page redirects to a new domain, first-party/third-party detection is base
 | `interact_clicks`    | Boolean | `false` | Enable element clicking simulation |
 | `interact_typing`    | Boolean | `false` | Enable typing simulation |
 | `interact_intensity` | String | `"medium"` | Interaction simulation intensity: "low", "medium", "high" |
+| `cursor_mode`        | `"ghost"` | - | Use ghost-cursor Bezier mouse movements (requires `npm i ghost-cursor`) |
+| `ghost_cursor_speed` | Number | auto | Ghost-cursor movement speed multiplier |
+| `ghost_cursor_hesitate` | Milliseconds | `50` | Delay before ghost-cursor clicks |
+| `ghost_cursor_overshoot` | Pixels | auto | Max ghost-cursor overshoot distance before correcting |
+| `ghost_cursor_duration` | Milliseconds | `interact_duration` or `2000` | How long ghost-cursor movements run |
 | `dnsmasq`            | Boolean | `false` | Force dnsmasq output for this site |
 | `dnsmasq_old`        | Boolean | `false` | Force dnsmasq old format output for this site |
 | `unbound`            | Boolean | `false` | Force unbound output for this site |
@@ -523,6 +531,27 @@ node nwss.js --max-concurrent 12 --cleanup-interval 300 -o rules.txt
 }
 ```
 
+#### Ghost Cursor (Advanced Bezier Mouse)
+```json
+{
+  "url": "https://anti-bot-site.com",
+  "interact": true,
+  "cursor_mode": "ghost",
+  "ghost_cursor_duration": 3000,
+  "ghost_cursor_speed": 1.2,
+  "fingerprint_protection": "random",
+  "filterRegex": "tracking|analytics",
+  "comments": "ghost-cursor uses Bezier curves with overshoot for realistic mouse paths"
+}
+```
+
+Or enable globally via CLI:
+```bash
+node nwss.js --ghost-cursor --debug -o rules.txt
+```
+
+> **Note:** ghost-cursor is an optional dependency. Install with `npm install ghost-cursor`. If not installed, the scanner falls back to the built-in mouse simulation automatically.
+
 #### E-commerce Site Scanning
 ```json
 {
@@ -698,5 +727,7 @@ your_username ALL=(root) NOPASSWD: /usr/bin/wg-quick, /usr/bin/wg
 - If an `.ovpn` file contains embedded credentials, no additional auth config is needed in the JSON
 - VPN affects system-level routing — all concurrent scans will route through the active tunnel
 - Both `vpn` (WireGuard) and `openvpn` can be set, but `vpn` takes precedence
+- Ghost-cursor (`cursor_mode: "ghost"`) is optional — install with `npm i ghost-cursor`. Falls back to built-in mouse if not installed
+- Ghost-cursor duration defaults to `interact_duration` (or 2000ms), capped by the 15s hard timeout
 
 ---

package/lib/adblock.js

@@ -51,11 +51,12 @@ function parseAdblockRules(filePath, options = {}) {
     caseSensitive = false
   } = options;
 
-  if (!fs.existsSync(filePath)) {
+  let fileContent;
+  try {
+    fileContent = fs.readFileSync(filePath, 'utf-8');
+  } catch (err) {
     throw new Error(`Adblock rules file not found: ${filePath}`);
   }
-
-  const fileContent = fs.readFileSync(filePath, 'utf-8');
   const lines = fileContent.split('\n');
   
   const rules = {

package/lib/browserexit.js

@@ -5,6 +5,7 @@
 
 
 const fs = require('fs');
+const path = require('path');
 const { execSync } = require('child_process');
 
 // Constants for temp file cleanup
@@ -15,20 +16,55 @@ const CHROME_TEMP_PATHS = [
 ];
 
 const CHROME_TEMP_PATTERNS = [
-  'com.google.Chrome.*',         // Google Chrome temp files (no leading dot)
-  '.org.chromium.Chromium.*',
-  'puppeteer-*'
+  /^\.?com\.google\.Chrome\./,
+  /^\.?org\.chromium\.Chromium\./,
+  /^puppeteer-/
 ];
 
+/**
+ * Count and remove matching Chrome/Puppeteer temp entries from a directory using fs
+ * @param {string} basePath - Directory to scan
+ * @param {boolean} forceDebug - Whether to output debug logs
+ * @returns {number} Number of items cleaned
+ */
+function cleanTempDir(basePath, forceDebug) {
+  let entries;
+  try {
+    entries = fs.readdirSync(basePath);
+  } catch {
+    if (forceDebug) console.log(`[debug] [temp-cleanup] Cannot read ${basePath}`);
+    return 0;
+  }
+
+  let cleaned = 0;
+  for (const entry of entries) {
+    let matched = false;
+    for (const re of CHROME_TEMP_PATTERNS) {
+      if (re.test(entry)) { matched = true; break; }
+    }
+    if (!matched) continue;
+
+    try {
+      fs.rmSync(path.join(basePath, entry), { recursive: true, force: true });
+      cleaned++;
+      if (forceDebug) console.log(`[debug] [temp-cleanup] Removed ${basePath}/${entry}`);
+    } catch (rmErr) {
+      if (forceDebug) console.log(`[debug] [temp-cleanup] Failed to remove ${basePath}/${entry}: ${rmErr.message}`);
+    }
+  }
+
+  return cleaned;
+}
+
 /**
  * Clean Chrome temporary files and directories
  * @param {Object} options - Cleanup options
  * @param {boolean} options.includeSnapTemp - Whether to clean snap temp directories
  * @param {boolean} options.forceDebug - Whether to output debug logs
  * @param {boolean} options.comprehensive - Whether to perform comprehensive cleanup of all temp locations
- * @returns {Promise<Object>} Cleanup results
+ * @returns {Object} Cleanup results
  */
-async function cleanupChromeTempFiles(options = {}) {
+function cleanupChromeTempFiles(options = {}) {
   const {
     includeSnapTemp = false,
     forceDebug = false,
@@ -36,57 +72,20 @@ async function cleanupChromeTempFiles(options = {}) {
   } = options;
 
   try {
-
-    // 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',
-      'rm -rf /dev/shm/.com.google.Chrome.* 2>/dev/null || true',
-      'rm -rf /dev/shm/.org.chromium.Chromium.* 2>/dev/null || true'
-    ];
-
-    // 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'
-      );
-    }
+    const paths = comprehensive || includeSnapTemp
+      ? CHROME_TEMP_PATHS
+      : CHROME_TEMP_PATHS.slice(0, 2); // /tmp and /dev/shm only
 
     let totalCleaned = 0;
-    
-    for (const command of cleanupCommands) {
-      try {
-        // Extract glob pattern and count matches before deletion
-        const globPattern = command.match(/rm -rf ([^ ]+)/)?.[1];
-        if (!globPattern) continue;
-        const fileCount = parseInt(execSync(`ls -1d ${globPattern} 2>/dev/null | wc -l || echo 0`, { stdio: 'pipe' }).toString().trim()) || 0;
-        
-        if (fileCount > 0) {
-          execSync(command, { stdio: 'ignore' });
-          totalCleaned += fileCount;
-          
-          if (forceDebug) {
-            console.log(`[debug] [temp-cleanup] Cleaned ${fileCount} items from ${globPattern}`);
-          }
-        }
-      } catch (cmdErr) {
-        // Ignore individual command errors but log in debug mode
-        if (forceDebug) {
-          console.log(`[debug] [temp-cleanup] Cleanup command failed: ${command} (${cmdErr.message})`);
-        }
-      }
+    for (const basePath of paths) {
+      totalCleaned += cleanTempDir(basePath, forceDebug);
     }
 
     if (forceDebug) {
-      console.log(`[debug] [temp-cleanup] Standard cleanup completed (${totalCleaned} items)`);
+      console.log(`[debug] [temp-cleanup] Cleanup completed (${totalCleaned} items)`);
     }
-    
+
     return { success: true, itemsCleaned: totalCleaned };
-    
   } catch (cleanupErr) {
     if (forceDebug) {
       console.log(`[debug] [temp-cleanup] Chrome cleanup error: ${cleanupErr.message}`);
@@ -96,72 +95,38 @@ async function cleanupChromeTempFiles(options = {}) {
 }
 
 /**
- * Comprehensive temp file cleanup that systematically checks all known Chrome temp locations
+ * Comprehensive temp file cleanup that checks all known Chrome temp locations
  * @param {Object} options - Cleanup options
  * @param {boolean} options.forceDebug - Whether to output debug logs
  * @param {boolean} options.verbose - Whether to show verbose output
- * @returns {Promise<Object>} Cleanup results
+ * @returns {Object} Cleanup results
  */
-async function comprehensiveChromeTempCleanup(options = {}) {
+function comprehensiveChromeTempCleanup(options = {}) {
   const { forceDebug = false, verbose = false } = options;
-  
+
   try {
-    let totalCleaned = 0;
-    
     if (verbose && !forceDebug) {
       console.log(`[temp-cleanup] Scanning Chrome/Puppeteer temporary files...`);
     }
-    
+
+    let totalCleaned = 0;
     for (const basePath of CHROME_TEMP_PATHS) {
-      // Check if the base path exists before trying to clean it
-      try {
-        const pathExists = fs.existsSync(basePath);
-        
-        if (!pathExists) {
-          if (forceDebug) {
-            console.log(`[debug] [temp-cleanup] Skipping non-existent path: ${basePath}`);
-          }
-          continue;
-        }
-        
-        for (const pattern of CHROME_TEMP_PATTERNS) {
-          const fullPattern = `${basePath}/${pattern}`;
-          
-          // Count items before deletion
-          const countCommand = `ls -1d ${fullPattern} 2>/dev/null | wc -l || echo 0`;
-          const itemCount = parseInt(execSync(countCommand, { stdio: 'pipe' }).toString().trim()) || 0;
-          
-          if (itemCount > 0) {
-            const deleteCommand = `rm -rf ${fullPattern} 2>/dev/null || true`;
-            execSync(deleteCommand, { stdio: 'ignore' });
-            totalCleaned += itemCount;
-            
-            if (forceDebug) {
-              console.log(`[debug] [temp-cleanup] Removed ${itemCount} items matching ${fullPattern}`);
-            }
-          }
-        }
-      } catch (pathErr) {
-        if (forceDebug) {
-          console.log(`[debug] [temp-cleanup] Error checking path ${basePath}: ${pathErr.message}`);
-        }
-      }
+      totalCleaned += cleanTempDir(basePath, forceDebug);
     }
-    
+
     if (verbose && totalCleaned > 0) {
-      console.log(`[temp-cleanup] ? Removed ${totalCleaned} temporary file(s)/folder(s)`);
+      console.log(`[temp-cleanup] Removed ${totalCleaned} temporary file(s)/folder(s)`);
     } else if (verbose && totalCleaned === 0) {
-      console.log(`[temp-cleanup] ? Clean - no remaining temporary files`);
+      console.log(`[temp-cleanup] Clean - no remaining temporary files`);
     } else if (forceDebug) {
       console.log(`[debug] [temp-cleanup] Comprehensive cleanup completed (${totalCleaned} items)`);
     }
-    
+
     return { success: true, itemsCleaned: totalCleaned };
-    
   } catch (err) {
     const errorMsg = `Comprehensive temp file cleanup failed: ${err.message}`;
     if (verbose) {
-      console.warn(`[temp-cleanup] ? ${errorMsg}`);
+      console.warn(`[temp-cleanup] ${errorMsg}`);
     } else if (forceDebug) {
       console.log(`[debug] [temp-cleanup] ${errorMsg}`);
     }
@@ -317,7 +282,7 @@ async function forceBrowserKill(browser, forceDebug = false) {
       }
       
       // Wait for graceful termination
-      await new Promise(resolve => setTimeout(resolve, 3000));
+      await new Promise(resolve => setTimeout(resolve, 1000));
       
       // Force kill any remaining processes with SIGKILL
       for (const pid of pidsToKill) {

package/lib/browserhealth.js

@@ -438,11 +438,12 @@ async function performRealtimeWindowCleanup(browserInstance, threshold = REALTIM
     let closedCount = 0;
     for (const page of safePagesToClose) {
       try {
-        // Cache both page state and URL for this iteration
         const isPageClosed = page.isClosed();
-        const pageUrl = page.url();
-        
-        if (!isPageClosed) {
+
+        // Re-check processing state — may have changed since safety check
+        const usage = pageUsageTracker.get(page);
+        if (!isPageClosed && !(usage && usage.isProcessing)) {
+          const pageUrl = page.url();
           await page.close();
           pageCreationTracker.delete(page); // Remove from tracker
           pageUsageTracker.delete(page);
@@ -569,6 +570,16 @@ function trackPageForRealtime(page) {
   updatePageUsage(page, false); // Initialize usage tracking
 }
 
+/**
+ * Removes a page from all tracking Maps immediately.
+ * Call this before page.close() to prevent stale entries during concurrent execution.
+ * @param {import('puppeteer').Page} page - Page to untrack
+ */
+function untrackPage(page) {
+  pageCreationTracker.delete(page);
+  pageUsageTracker.delete(page);
+}
+
 /**
  * Purges stale entries from tracking Maps (pages that were closed without cleanup)
  * Should be called periodically to prevent memory leaks
@@ -1225,6 +1236,7 @@ module.exports = {
   isBrowserHealthy,
   isCriticalProtocolError,
   updatePageUsage,
+  untrackPage,
   cleanupPageBeforeReload,
   purgeStaleTrackers
 };

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

@@ -9,10 +9,6 @@ const path = require('path');
  */
 function loadComparisonRules(compareFilePath, forceDebug = false) {
   try {
-    if (!fs.existsSync(compareFilePath)) {
-      throw new Error(`Comparison file not found: ${compareFilePath}`);
-    }
-    
     const content = fs.readFileSync(compareFilePath, 'utf8');
     const lines = content.split('\n')
       .map(line => line.trim())