@fanboynz/network-scanner 2.0.66 → 3.0.1

package/lib/dry-run.js

@@ -4,11 +4,13 @@
 const fs = require('fs');
 const { messageColors, formatLogMessage } = require('./colorize');
 
-// Constants for dry run collection keys
+// Constants for dry run collection keys. SEARCH_STRING was removed —
+// addDryRunSearchString had zero callers, so the map was never populated
+// and the downstream "Searchstring Match" enhancement always produced
+// null. See the cleanup comment in processDryRunResults.
 const DRY_RUN_KEYS = {
   MATCHES: 'dryRunMatches',
-  NET_TOOLS: 'dryRunNetTools',
-  SEARCH_STRING: 'dryRunSearchString'
+  NET_TOOLS: 'dryRunNetTools'
 };
 
 /**
@@ -23,7 +25,6 @@ function initializeDryRunCollections(matchedDomains) {
   
   matchedDomains.set(DRY_RUN_KEYS.MATCHES, []);
   matchedDomains.set(DRY_RUN_KEYS.NET_TOOLS, []);
-  matchedDomains.set(DRY_RUN_KEYS.SEARCH_STRING, new Map());
 }
 
 /**
@@ -35,10 +36,15 @@ function validateMatchData(matchData) {
   if (!matchData || typeof matchData !== 'object') {
     throw new Error('Match data must be an object');
   }
-  
+
   const requiredFields = ['regex', 'domain', 'resourceType', 'fullUrl'];
   for (const field of requiredFields) {
-    if (!(field in matchData)) {
+    // Check VALUE, not just key presence. The old `field in matchData`
+    // accepted `{regex: undefined, ...}` because `in` only tests for
+    // the property's existence on the object. The downstream output
+    // then printed 'unknown' via `item.regex || 'unknown'` defensive
+    // fallbacks — validation that doesn't catch this defeats its purpose.
+    if (matchData[field] === undefined || matchData[field] === null) {
       throw new Error(`Match data missing required field: ${field}`);
     }
   }
@@ -53,10 +59,11 @@ function validateNetToolsData(netToolsData) {
   if (!netToolsData || typeof netToolsData !== 'object') {
     throw new Error('NetTools data must be an object');
   }
-  
+
   const requiredFields = ['domain', 'tool', 'matchType', 'matchedTerm'];
   for (const field of requiredFields) {
-    if (!(field in netToolsData)) {
+    // Value check (see validateMatchData for the rationale).
+    if (netToolsData[field] === undefined || netToolsData[field] === null) {
       throw new Error(`NetTools data missing required field: ${field}`);
     }
   }
@@ -108,36 +115,6 @@ function addDryRunNetTools(matchedDomains, netToolsData) {
   });
 }
 
-/**
- * Add a search string result to dry run collections
- * @param {Map} matchedDomains - The matched domains map
- * @param {string} url - The URL that was searched
- * @param {Object} searchResult - Search result data
- * @throws {Error} If parameters are invalid
- */
-function addDryRunSearchString(matchedDomains, url, searchResult) {
-  if (!(matchedDomains instanceof Map)) {
-    throw new Error('matchedDomains must be a Map instance');
-  }
-  
-  if (!url || typeof url !== 'string') {
-    throw new Error('URL must be a non-empty string');
-  }
-  
-  if (!searchResult || typeof searchResult !== 'object') {
-    throw new Error('Search result must be an object');
-  }
-  
-  if (!matchedDomains.has(DRY_RUN_KEYS.SEARCH_STRING)) {
-    throw new Error('Dry run collections not initialized. Call initializeDryRunCollections first.');
-  }
-  
-  matchedDomains.get(DRY_RUN_KEYS.SEARCH_STRING).set(url, {
-    ...searchResult,
-    timestamp: new Date().toISOString()
-  });
-}
-
 /**
  * Safely truncate long URLs for display
  * @param {string} url - URL to truncate
@@ -151,19 +128,6 @@ function truncateUrl(url, maxLength = 80) {
   return url.substring(0, maxLength - 3) + '...';
 }
 
-/**
- * Format search string match information
- * @param {Object} searchStringMatch - Search string match data
- * @returns {string} Formatted match description
- */
-function formatSearchStringMatch(searchStringMatch) {
-  if (!searchStringMatch) return null;
-  
-  const matchType = searchStringMatch.type || 'unknown';
-  const term = searchStringMatch.term || 'unknown';
-  return `${matchType} - "${term}"`;
-}
-
 /**
  * Generate adblock rule from domain and resource type
  * @param {string} domain - Domain name
@@ -192,112 +156,130 @@ function generateAdblockRule(domain, resourceType = null) {
 function outputDryRunResults(url, matchedItems = [], netToolsResults = [], pageTitle = '', outputFile = null, dryRunOutput = []) {
   try {
     const lines = [];
+
+    // emit() — single source of truth for output. Writes the plain
+    // version to the file-output array AND the (possibly colored)
+    // version to the console. Previously every output line was a
+    // paired lines.push(...) + console.log(...) statement, often in
+    // separate blocks (file pushes first, then console logs), so
+    // drift between file and terminal output was a real risk every
+    // time someone edited only one half of a pair.
+    const emit = (plain, colored = plain) => {
+      lines.push(plain);
+      console.log(colored);
+    };
+
     const truncatedUrl = truncateUrl(url);
-    
-    lines.push(`\n=== DRY RUN RESULTS === ${truncatedUrl}`);
-    console.log(`\n${messageColors.scanning('=== DRY RUN RESULTS ===')} ${truncatedUrl}`);
-    
+
+    emit(
+      `\n=== DRY RUN RESULTS === ${truncatedUrl}`,
+      `\n${messageColors.scanning('=== DRY RUN RESULTS ===')} ${truncatedUrl}`
+    );
+
     if (pageTitle && pageTitle.trim()) {
       const cleanTitle = pageTitle.trim().substring(0, 200); // Limit title length
-      lines.push(`Title: ${cleanTitle}`);
-      console.log(`${messageColors.info('Title:')} ${cleanTitle}`);
+      emit(
+        `Title: ${cleanTitle}`,
+        `${messageColors.info('Title:')} ${cleanTitle}`
+      );
     }
-    
+
     const totalMatches = matchedItems.length + netToolsResults.length;
-    
+
     if (totalMatches === 0) {
       const noMatchMsg = `No matching rules found on ${truncatedUrl}`;
-      lines.push(noMatchMsg);
-      
+      emit(noMatchMsg, messageColors.warn(noMatchMsg));
+
       if (outputFile) {
         dryRunOutput.push(...lines);
         dryRunOutput.push(''); // Add empty line
       }
-      console.log(messageColors.warn(noMatchMsg));
       return;
     }
-    
-    lines.push(`Matches found: ${totalMatches}`);
-    console.log(`${messageColors.success('Matches found:')} ${totalMatches}`);
-    
+
+    emit(
+      `Matches found: ${totalMatches}`,
+      `${messageColors.success('Matches found:')} ${totalMatches}`
+    );
+
     // Process regex matches
     matchedItems.forEach((item, index) => {
       try {
-        lines.push('');
-        lines.push(`[${index + 1}] Regex Match:`);
-        lines.push(`  Pattern: ${item.regex || 'unknown'}`);
-        lines.push(`  Domain: ${item.domain || 'unknown'}`);
-        lines.push(`  Resource Type: ${item.resourceType || 'unknown'}`);
-        lines.push(`  Full URL: ${truncateUrl(item.fullUrl || '')}`);
-
-        console.log(`\n${messageColors.highlight(`[${index + 1}]`)} ${messageColors.match('Regex Match:')}`);
-        console.log(`  Pattern: ${item.regex || 'unknown'}`);
-        console.log(`  Domain: ${item.domain || 'unknown'}`);
-        console.log(`  Resource Type: ${item.resourceType || 'unknown'}`);
-        console.log(`  Full URL: ${truncateUrl(item.fullUrl || '')}`);
-        
-        // Show blocked status if applicable
+        emit(''); // blank separator before each match item
+        emit(
+          `[${index + 1}] Regex Match:`,
+          `${messageColors.highlight(`[${index + 1}]`)} ${messageColors.match('Regex Match:')}`
+        );
+        emit(`  Pattern: ${item.regex || 'unknown'}`);
+        emit(`  Domain: ${item.domain || 'unknown'}`);
+        emit(`  Resource Type: ${item.resourceType || 'unknown'}`);
+        emit(`  Full URL: ${truncateUrl(item.fullUrl || '')}`);
+
         if (item.wasBlocked) {
-          lines.push(`  Status: BLOCKED (even_blocked enabled)`);
-          console.log(`  ${messageColors.warn('Status:')} BLOCKED (even_blocked enabled)`);
+          emit(
+            `  Status: BLOCKED (even_blocked enabled)`,
+            `  ${messageColors.warn('Status:')} BLOCKED (even_blocked enabled)`
+          );
         }
-        
-        // Show searchstring results if available
-        if (item.searchStringMatch) {
-          const matchDesc = formatSearchStringMatch(item.searchStringMatch);
-          lines.push(`  ? Searchstring Match: ${matchDesc}`);
-          console.log(`  ${messageColors.success('? Searchstring Match:')} ${matchDesc}`);
-        } else if (item.searchStringChecked) {
-          lines.push(`  ? Searchstring: No matches found in content`);
-          console.log(`  ${messageColors.warn('? Searchstring:')} No matches found in content`);
+
+        // Searchstring "not found" — see processDryRunResults comment
+        // for why the positive-match branch was removed.
+        if (item.searchStringChecked) {
+          emit(
+            `  ✗ Searchstring: No matches found in content`,
+            `  ${messageColors.warn('✗ Searchstring:')} No matches found in content`
+          );
         }
-        
-        // Generate adblock rule
+
         const adblockRule = generateAdblockRule(item.domain, item.resourceType);
-        lines.push(`  Adblock Rule: ${adblockRule}`);
-        console.log(`  ${messageColors.info('Adblock Rule:')} ${adblockRule}`);
-        
+        emit(
+          `  Adblock Rule: ${adblockRule}`,
+          `  ${messageColors.info('Adblock Rule:')} ${adblockRule}`
+        );
+
       } catch (itemErr) {
         const errorMsg = `Error processing match item ${index + 1}: ${itemErr.message}`;
-        lines.push(`  Error: ${errorMsg}`);
-        console.log(`  ${messageColors.warn('Error:')} ${errorMsg}`);
+        emit(
+          `  Error: ${errorMsg}`,
+          `  ${messageColors.warn('Error:')} ${errorMsg}`
+        );
       }
     });
-    
-    // Process nettools results  
+
+    // Process nettools results
     netToolsResults.forEach((result, index) => {
       try {
         const resultIndex = matchedItems.length + index + 1;
-        lines.push('');
-        lines.push(`[${resultIndex}] NetTools Match:`);
-        lines.push(`  Domain: ${result.domain || 'unknown'}`);
-        lines.push(`  Tool: ${(result.tool || 'unknown').toUpperCase()}`);
-        
+        emit(''); // blank separator before each nettools item
+        emit(
+          `[${resultIndex}] NetTools Match:`,
+          `${messageColors.highlight(`[${resultIndex}]`)} ${messageColors.match('NetTools Match:')}`
+        );
+        emit(`  Domain: ${result.domain || 'unknown'}`);
+        emit(`  Tool: ${(result.tool || 'unknown').toUpperCase()}`);
+
         const matchDesc = `${result.matchType || 'unknown'} - "${result.matchedTerm || 'unknown'}"`;
-        lines.push(`  ? Match: ${matchDesc}`);
-        
-        if (result.details) {
-          lines.push(`  Details: ${result.details}`);
-        }
-        
-        console.log(`\n${messageColors.highlight(`[${resultIndex}]`)} ${messageColors.match('NetTools Match:')}`);
-        console.log(`  Domain: ${result.domain || 'unknown'}`);
-        console.log(`  Tool: ${(result.tool || 'unknown').toUpperCase()}`);
-        console.log(`  ${messageColors.success('? Match:')} ${matchDesc}`);
-        
+        emit(
+          `  ✓ Match: ${matchDesc}`,
+          `  ${messageColors.success('✓ Match:')} ${matchDesc}`
+        );
+
         if (result.details) {
-          console.log(`  Details: ${result.details}`);
+          emit(`  Details: ${result.details}`);
         }
-        
-        // Generate adblock rule for nettools matches
+
         const adblockRule = generateAdblockRule(result.domain);
-        lines.push(`  Adblock Rule: ${adblockRule}`);
-        console.log(`  ${messageColors.info('Adblock Rule:')} ${adblockRule}`);
-        
+        emit(
+          `  Adblock Rule: ${adblockRule}`,
+          `  ${messageColors.info('Adblock Rule:')} ${adblockRule}`
+        );
+
       } catch (resultErr) {
         const errorMsg = `Error processing nettools result ${index + 1}: ${resultErr.message}`;
-        lines.push(`  Error: ${errorMsg}`);
-        console.log(`  ${messageColors.warn('Error:')} ${errorMsg}`);
+        emit(
+          `  Error: ${errorMsg}`,
+          `  ${messageColors.warn('Error:')} ${errorMsg}`
+        );
       }
     });
 
@@ -306,7 +288,7 @@ function outputDryRunResults(url, matchedItems = [], netToolsResults = [], pageT
       dryRunOutput.push(...lines);
       dryRunOutput.push(''); // Add empty line between sites
     }
-    
+
   } catch (outputErr) {
     const errorMsg = `Error in outputDryRunResults: ${outputErr.message}`;
     console.error(messageColors.error(errorMsg));
@@ -347,34 +329,27 @@ async function processDryRunResults(currentUrl, matchedDomains, page, outputFile
       if (forceDebug) {
         console.log(formatLogMessage('debug', `Failed to get page title for ${currentUrl}: ${titleErr.message}`));
       }
-      pageTitle = 'Title unavailable';
+      // Leave pageTitle as '' (its initial value) on failure — the
+      // truthy check in outputDryRunResults then skips the Title line
+      // entirely. Previously we set 'Title unavailable' here, which
+      // was truthy and got printed as if it were the page's real
+      // title: 'Title: Title unavailable'.
     }
     
     // Get collected matches with safe fallbacks
     const dryRunMatches = matchedDomains.get(DRY_RUN_KEYS.MATCHES) || [];
     const dryRunNetTools = matchedDomains.get(DRY_RUN_KEYS.NET_TOOLS) || [];
-    const dryRunSearchString = matchedDomains.get(DRY_RUN_KEYS.SEARCH_STRING) || new Map();
-    
-    // Enhance matches with searchstring results
-    const enhancedMatches = dryRunMatches.map((match, index) => {
-      try {
-        const searchResult = dryRunSearchString.get(match.fullUrl);
-        return {
-          ...match,
-          searchStringMatch: searchResult && searchResult.matched ? searchResult : null,
-          searchStringChecked: Boolean(match.needsSearchStringCheck)
-        };
-      } catch (enhanceErr) {
-        if (forceDebug) {
-          console.log(formatLogMessage('debug', `Error enhancing match ${index}: ${enhanceErr.message}`));
-        }
-        return {
-          ...match,
-          searchStringMatch: null,
-          searchStringChecked: false
-        };
-      }
-    });
+
+    // Enhance matches with the searchstring-checked flag from the
+    // incoming match data. Previously this also looked up positive
+    // searchstring results in a `dryRunSearchString` Map — but
+    // `addDryRunSearchString` was never wired to any caller, so the
+    // map was always empty and `searchStringMatch` was always null.
+    // Removed that dead lookup and the per-item try/catch it required.
+    const enhancedMatches = dryRunMatches.map((match) => ({
+      ...match,
+      searchStringChecked: Boolean(match.needsSearchStringCheck)
+    }));
     
     outputDryRunResults(currentUrl, enhancedMatches, dryRunNetTools, pageTitle, outputFile, dryRunOutput);
     
@@ -443,7 +418,7 @@ function writeDryRunOutput(outputFile, dryRunOutput, silentMode = false) {
     fs.writeFileSync(outputFile, dryRunContent);
     
     if (!silentMode) {
-      console.log(`${messageColors.fileOp('?? Dry run results saved to:')} ${outputFile}`);
+      console.log(`${messageColors.fileOp('📄 Dry run results saved to:')} ${outputFile}`);
     }
     
     return { 
@@ -456,60 +431,28 @@ function writeDryRunOutput(outputFile, dryRunOutput, silentMode = false) {
     
   } catch (writeErr) {
     const errorMsg = `Failed to write dry run output to ${outputFile}: ${writeErr.message}`;
-    console.error(`? ${errorMsg}`);
-    
-    return { 
-      success: false, 
+    // Matches outputDryRunResults / processDryRunResults error format —
+    // was bare `console.error('✗ ${errorMsg}')` here, the odd one out
+    // among the three error paths in this module.
+    console.error(messageColors.error(errorMsg));
+
+    return {
+      success: false,
       error: errorMsg,
       written: false
     };
   }
 }
 
-/**
- * Get statistics from dry run collections
- * @param {Map} matchedDomains - The matched domains map
- * @returns {Object} Statistics object
- */
-function getDryRunStats(matchedDomains) {
-  if (!(matchedDomains instanceof Map)) {
-    return { error: 'Invalid matchedDomains Map' };
-  }
-  
-  const matches = matchedDomains.get(DRY_RUN_KEYS.MATCHES) || [];
-  const netTools = matchedDomains.get(DRY_RUN_KEYS.NET_TOOLS) || [];
-  const searchStrings = matchedDomains.get(DRY_RUN_KEYS.SEARCH_STRING) || new Map();
-  
-  return {
-    totalMatches: matches.length + netTools.length,
-    regexMatches: matches.length,
-    netToolsMatches: netTools.length,
-    searchStringResults: searchStrings.size,
-    domains: new Set([
-      ...matches.map(m => m.domain).filter(Boolean),
-      ...netTools.map(n => n.domain).filter(Boolean)
-    ]).size
-  };
-}
-
+// Public surface used by nwss.js. Internal helpers (truncateUrl,
+// generateAdblockRule, validateMatchData, validateNetToolsData,
+// outputDryRunResults) stay module-private. DRY_RUN_KEYS, getDryRunStats,
+// addDryRunSearchString, and formatSearchStringMatch were removed —
+// see comments at their original sites for details.
 module.exports = {
-  // Constants
-  DRY_RUN_KEYS,
-  
-  // Core functions
   initializeDryRunCollections,
   addDryRunMatch,
   addDryRunNetTools,
-  addDryRunSearchString,
   processDryRunResults,
-  writeDryRunOutput,
-  
-  // Utility functions
-  getDryRunStats,
-  validateMatchData,
-  validateNetToolsData,
-  truncateUrl,
-  formatSearchStringMatch,
-  generateAdblockRule,
-  outputDryRunResults
+  writeDryRunOutput
 };