@fanboynz/network-scanner 2.0.66 → 3.0.0

package/lib/openvpn_vpn.js

@@ -11,7 +11,8 @@
 const { execSync, spawn } = require('child_process');
 const fs = require('fs');
 const path = require('path');
-const { formatLogMessage } = require('./colorize');
+const { formatLogMessage, messageColors } = require('./colorize');
+const OPENVPN_TAG = messageColors.processing('[openvpn]');
 
 /**
  * Fetch external IP address through the active tunnel
@@ -263,7 +264,7 @@ function waitForConnection(child, logPath, timeout, forceDebug) {
           const tunDevice = findTunDevice(child.pid);
           if (forceDebug) {
             console.log(formatLogMessage('debug',
-              `[openvpn] Connected (tun: ${tunDevice || 'unknown'}, ${Date.now() - startTime}ms)`
+              `${OPENVPN_TAG} Connected (tun: ${tunDevice || 'unknown'}, ${Date.now() - startTime}ms)`
             ));
           }
           done({ connected: true, tunDevice });
@@ -352,7 +353,7 @@ async function startConnection(configPath, vpnConfig, forceDebug = false) {
 
   if (activeConnections.has(connectionName)) {
     if (forceDebug) {
-      console.log(formatLogMessage('debug', `[openvpn] ${connectionName} already active`));
+      console.log(formatLogMessage('debug', `${OPENVPN_TAG} ${connectionName} already active`));
     }
     const existing = activeConnections.get(connectionName);
     return { success: true, connection: connectionName, tunDevice: existing.tunDevice, alreadyActive: true };
@@ -379,7 +380,7 @@ async function startConnection(configPath, vpnConfig, forceDebug = false) {
   const args = buildArgs(configPath, vpnConfig, connectionName, logPath);
 
   if (forceDebug) {
-    console.log(formatLogMessage('debug', `[openvpn] Starting: openvpn ${args.join(' ')}`));
+    console.log(formatLogMessage('debug', `${OPENVPN_TAG} Starting: openvpn ${args.join(' ')}`));
   }
 
   // Spawn OpenVPN — it daemonizes itself via --daemon, but we spawn
@@ -458,7 +459,7 @@ function stopConnection(connectionName, forceDebug = false) {
   } catch (killErr) {
     // Process may already be dead
     if (forceDebug) {
-      console.log(formatLogMessage('debug', `[openvpn] Kill error (may be already dead): ${killErr.message}`));
+      console.log(formatLogMessage('debug', `${OPENVPN_TAG} Kill error (may be already dead): ${killErr.message}`));
     }
   }
 
@@ -468,7 +469,7 @@ function stopConnection(connectionName, forceDebug = false) {
   cleanupConnectionFiles(connectionName);
 
   if (forceDebug) {
-    console.log(formatLogMessage('debug', `[openvpn] ${connectionName} stopped`));
+    console.log(formatLogMessage('debug', `${OPENVPN_TAG} ${connectionName} stopped`));
   }
 
   return { success: true };
@@ -544,7 +545,7 @@ function checkConnection(connectionName, testHost = '1.1.1.1', forceDebug = fals
 
     if (forceDebug) {
       console.log(formatLogMessage('debug',
-        `[openvpn] ${connectionName} connected (${latencyMs ? latencyMs + 'ms' : 'ok'})`
+        `${OPENVPN_TAG} ${connectionName} connected (${latencyMs ? latencyMs + 'ms' : 'ok'})`
       ));
     }
 
@@ -552,7 +553,7 @@ function checkConnection(connectionName, testHost = '1.1.1.1', forceDebug = fals
   } catch (error) {
     if (forceDebug) {
       console.log(formatLogMessage('debug',
-        `[openvpn] ${connectionName} health check failed: ${error.message.split('\n')[0]}`
+        `${OPENVPN_TAG} ${connectionName} health check failed: ${error.message.split('\n')[0]}`
       ));
     }
     return { connected: false, error: error.message.split('\n')[0] };
@@ -756,7 +757,7 @@ async function connectForSite(siteConfig, forceDebug = false) {
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     if (forceDebug && attempt > 1) {
       console.log(formatLogMessage('debug',
-        `[openvpn] Retry ${attempt - 1}/${ovpnConfig.max_retries} for ${connectionName}`
+        `${OPENVPN_TAG} Retry ${attempt - 1}/${ovpnConfig.max_retries} for ${connectionName}`
       ));
     }
 
@@ -833,7 +834,7 @@ function disconnectForSite(siteConfig, forceDebug = false) {
 
   if (forceDebug) {
     console.log(formatLogMessage('debug',
-      `[openvpn] ${connectionName} still used by ${info.sites.size} site(s), keeping up`
+      `${OPENVPN_TAG} ${connectionName} still used by ${info.sites.size} site(s), keeping up`
     ));
   }
 
@@ -863,7 +864,7 @@ function disconnectAll(forceDebug = false) {
 
   if (forceDebug && results.tornDown > 0) {
     console.log(formatLogMessage('debug',
-      `[openvpn] Disconnected ${results.tornDown} connection(s)`
+      `${OPENVPN_TAG} Disconnected ${results.tornDown} connection(s)`
     ));
   }
 

package/lib/output.js

@@ -1,9 +1,8 @@
 const fs = require('fs');
 const path = require('path');
-// Import domain cache functions for statistics
-const { getTotalDomainsSkipped } = require('./domain-cache');
 const { loadComparisonRules, filterUniqueRules } = require('./compare');
-const { colorize, colors, messageColors, tags, formatLogMessage } = require('./colorize');
+const { messageColors, formatLogMessage } = require('./colorize');
+const OUTPUT_FILTER_TAG = messageColors.processing('[output-filter]');
 
 // Cache for compiled wildcard regex patterns in matchesIgnoreDomain (capped to prevent memory leak)
 const wildcardRegexCache = new Map();
@@ -40,15 +39,28 @@ function matchesIgnoreDomain(domain, ignorePatterns) {
         const baseDomain = pattern.slice(0, -2); // Remove ".*"
         return domain.startsWith(baseDomain + '.');
       } else {
-        // Complex wildcard pattern (cached)
+        // Complex wildcard pattern (cached). Escape every regex meta-char
+        // EXCEPT '*' first, then expand '*' to '.*'. The old code only
+        // escaped '.', so a pattern containing '+', '(', '[', '?', etc.
+        // would either misbehave (e.g. 'foo+bar.com' would treat '+' as a
+        // quantifier) or throw synchronously (unmatched '(' / '[') and the
+        // exception would propagate out of .some(). Domain names can't
+        // legally contain those chars, but a typo in a user's ignore list
+        // would crash the output stage.
         if (!wildcardRegexCache.has(pattern)) {
           if (wildcardRegexCache.size >= WILDCARD_CACHE_MAX) {
             wildcardRegexCache.delete(wildcardRegexCache.keys().next().value);
           }
           const regexPattern = pattern
-            .replace(/\./g, '\\.')  // Escape dots
-            .replace(/\*/g, '.*');  // Convert * to .*
-          wildcardRegexCache.set(pattern, new RegExp(`^${regexPattern}$`));
+            .replace(/[.+?^${}()|[\]\\]/g, '\\$&')  // Escape all regex meta-chars except '*'
+            .replace(/\*/g, '.*');                  // Now expand '*' to '.*'
+          try {
+            wildcardRegexCache.set(pattern, new RegExp(`^${regexPattern}$`));
+          } catch (_) {
+            // Defensive: a still-malformed regex (shouldn't happen after the
+            // escape above) becomes a never-match instead of a crash.
+            wildcardRegexCache.set(pattern, /(?!)/);
+          }
         }
         return wildcardRegexCache.get(pattern).test(domain);
       }
@@ -389,7 +401,7 @@ function buildOutputLines(results, options = {}) {
         if (domain && matchesIgnoreDomain(domain, ignoreDomains)) {
           filteredOutCount++;
           if (options.forceDebug) {
-            console.log(formatLogMessage('debug', `[output-filter] Removed rule matching ignoreDomains: ${rule} (domain: ${domain})`));
+            console.log(formatLogMessage('debug', `${OUTPUT_FILTER_TAG} Removed rule matching ignoreDomains: ${rule} (domain: ${domain})`));
           } else if (!options.silentMode) {
             console.log(formatLogMessage('info', `Filtered out: ${domain}`));
           }
@@ -409,7 +421,7 @@ function buildOutputLines(results, options = {}) {
   // Log filtered domains if any were removed
   if (filteredOutCount > 0) {
     if (options.forceDebug) {
-      console.log(formatLogMessage('debug', `[output-filter] Total: ${filteredOutCount} rules filtered out matching ignoreDomains patterns`));
+      console.log(formatLogMessage('debug', `${OUTPUT_FILTER_TAG} Total: ${filteredOutCount} rules filtered out matching ignoreDomains patterns`));
     } else if (!options.silentMode) {
       console.log(formatLogMessage('info', `${filteredOutCount} domains filtered out by ignoreDomains`));
     }
@@ -456,7 +468,7 @@ function writeOutput(lines, outputFile = null, silentMode = false) {
     }
     return true;
   } catch (error) {
-    console.error(`? Failed to write output: ${error.message}`);
+    console.error(`Failed to write output: ${error.message}`);
     return false;
   }
 }
@@ -478,39 +490,41 @@ function handleOutput(results, config = {}) {
     dumpUrls = false,
     adblockRulesLogFile = null,
     forceDebug = false,
-    ignoreDomains = [],
-    totalDomainsSkipped = null  // Allow override or get from cache
+    ignoreDomains = []
   } = config;
   
   // Handle append mode
   if (outputFile && appendMode) {
     try {
-      // Build output lines first
-      const { 
-        outputLines, 
-        outputLinesWithTitles, 
+      // Build output lines first. buildOutputLines already applies
+      // removeDuplicates internally when removeDupes is true, so we don't
+      // need a second pass here.
+      const {
+        outputLines,
+        outputLinesWithTitles,
         successfulPageLoads,
         totalRules,
         filteredOutCount
-      } = buildOutputLines(results, { showTitles, removeDupes, ignoreDomains: config.ignoreDomains, forceDebug: config.forceDebug });
-
-      // Apply remove-dupes to new results if requested (before comparing to existing file)
-      const deduplicatedOutputLines = removeDupes ? removeDuplicates(outputLines) : outputLines;
-      if (removeDupes && forceDebug) console.log(formatLogMessage('debug', `Applied --remove-dupes to new scan results before append comparison`));
+      } = buildOutputLines(results, { showTitles, removeDupes, ignoreDomains, forceDebug });
+      const deduplicatedOutputLines = outputLines;
       
-      // Read existing file content
+      // Read existing file content via a single open() instead of stat+open
+      // (and avoid TOCTOU between an existsSync check and the read).
       let existingContent = '';
-      if (fs.existsSync(outputFile)) {
+      try {
         existingContent = fs.readFileSync(outputFile, 'utf8');
-      } else {
+      } catch (readErr) {
+        if (readErr.code !== 'ENOENT') throw readErr;
         // File doesn't exist - append mode should create it
         if (forceDebug) console.log(formatLogMessage('debug', `Append mode: Creating new file ${outputFile}`));
       }
-      
-      // Parse existing rules for comparison (exclude comments)
+
+      // Parse existing rules for comparison (exclude comments). Hoist the
+      // single .trim() into a local so we don't walk the file content twice.
       const existingRules = new Set();
-      if (existingContent.trim()) {
-        const lines = existingContent.trim().split('\n');
+      const trimmedExisting = existingContent.trim();
+      if (trimmedExisting) {
+        const lines = trimmedExisting.split('\n');
         lines.forEach(line => {
           const cleanLine = line.trim();
           if (cleanLine && !cleanLine.startsWith('!') && !cleanLine.startsWith('#')) {
@@ -524,39 +538,47 @@ function handleOutput(results, config = {}) {
         return rule.startsWith('!') || !existingRules.has(rule);
       });
       
+      // Count non-comment rules once and reuse below (was three throwaway
+      // filter-array allocations: success log, else-branch log, return obj).
+      let newRuleCount = 0;
+      for (let i = 0; i < newRules.length; i++) {
+        if (!newRules[i].startsWith('!')) newRuleCount++;
+      }
+
       if (newRules.length > 0) {
         // Prepare content to append
         let appendContent = '';
-        
+
         // Ensure there's a newline before appending if file has content
         if (existingContent && !existingContent.endsWith('\n')) {
           appendContent = '\n';
         }
-        
+
         // Add new rules
         appendContent += newRules.join('\n') + '\n';
-        
+
         // Append to file
         fs.appendFileSync(outputFile, appendContent);
-        
-        const newRuleCount = newRules.filter(rule => !rule.startsWith('!')).length;
+
         if (!silentMode) {
-          console.log(`${messageColors.success('? Appended')} ${newRuleCount} new rules to: ${outputFile} (${existingRules.size} rules already existed${removeDupes ? ', duplicates removed' : ''})`);
+          console.log(`${messageColors.success('Appended')} ${newRuleCount} new rules to: ${outputFile} (${existingRules.size} rules already existed${removeDupes ? ', duplicates removed' : ''})`);
         }
-      } else {
-        if (!silentMode) {
-          const ruleCount = deduplicatedOutputLines.filter(rule => !rule.startsWith('!')).length;
-          console.log(`${messageColors.info('?')} No new rules to append - all ${ruleCount} rules already exist in: ${outputFile}`);
+      } else if (!silentMode) {
+        // No new rules — report the dedup'd input count instead. Same loop
+        // pattern as above to avoid filter().length allocating an array.
+        let ruleCount = 0;
+        for (let i = 0; i < deduplicatedOutputLines.length; i++) {
+          if (!deduplicatedOutputLines[i].startsWith('!')) ruleCount++;
         }
+        console.log(`${messageColors.info('No new rules')} to append - all ${ruleCount} rules already exist in: ${outputFile}`);
       }
-      
+
       // Write log file output if --dumpurls is enabled
       let logSuccess = true;
       if (dumpUrls && adblockRulesLogFile) {
         logSuccess = writeOutput(outputLinesWithTitles, adblockRulesLogFile, silentMode);
       }
-      
-      const newRuleCount = newRules.filter(rule => !rule.startsWith('!')).length;
+
       return {
         success: logSuccess,
         outputFile,
@@ -571,34 +593,42 @@ function handleOutput(results, config = {}) {
       };
       
     } catch (appendErr) {
-      console.error(`? Failed to append to ${outputFile}: ${appendErr.message}`);
+      console.error(`Failed to append to ${outputFile}: ${appendErr.message}`);
       return { success: false };
     }
   }
 
   // Build output lines
-  const { 
-    outputLines, 
-    outputLinesWithTitles, 
+  const {
+    outputLines,
+    outputLinesWithTitles,
     successfulPageLoads,
     totalRules,
     filteredOutCount
-  } = buildOutputLines(results, { showTitles, removeDupes, ignoreDomains: config.ignoreDomains, forceDebug: config.forceDebug });
+  } = buildOutputLines(results, { showTitles, removeDupes, ignoreDomains, forceDebug });
   
   // Apply comparison filtering if compareFile is specified
   let filteredOutputLines = outputLines;
   if (compareFile && outputLines.length > 0) {
     try {
-      const comparisonRules = loadComparisonRules(compareFile, config.forceDebug);
-      const originalCount = outputLines.filter(line => !line.startsWith('!')).length;
-      filteredOutputLines = filterUniqueRules(outputLines, comparisonRules, config.forceDebug);
-      
-      if (!silentMode) {
-        console.log(formatLogMessage('compare', `Filtered ${originalCount - filteredOutputLines.filter(line => !line.startsWith('!')).length} existing rules, ${filteredOutputLines.filter(line => !line.startsWith('!')).length} unique rules remaining`));
+      const comparisonRules = loadComparisonRules(compareFile, forceDebug);
+      // Count non-comment lines once each side instead of building filter
+      // arrays just to read .length (was three allocations per log line).
+      let originalCount = 0;
+      for (let i = 0; i < outputLines.length; i++) {
+        if (!outputLines[i].startsWith('!')) originalCount++;
+      }
+      filteredOutputLines = filterUniqueRules(outputLines, comparisonRules, forceDebug);
 
+      if (!silentMode) {
+        let uniqueCount = 0;
+        for (let i = 0; i < filteredOutputLines.length; i++) {
+          if (!filteredOutputLines[i].startsWith('!')) uniqueCount++;
+        }
+        console.log(formatLogMessage('compare', `Filtered ${originalCount - uniqueCount} existing rules, ${uniqueCount} unique rules remaining`));
       }
     } catch (compareError) {
-      console.error(messageColors.error('❌ Compare operation failed:') + ` ${compareError.message}`);
+      console.error(messageColors.error('Compare operation failed:') + ` ${compareError.message}`);
       return { success: false, totalRules: 0, successfulPageLoads: 0 };
     }
   }
@@ -612,21 +642,24 @@ function handleOutput(results, config = {}) {
     logSuccess = writeOutput(outputLinesWithTitles, adblockRulesLogFile, silentMode);
   }
 
-  // Get domain skip statistics from cache if not provided
-  const finalTotalDomainsSkipped = totalDomainsSkipped !== null ? 
-    totalDomainsSkipped : getTotalDomainsSkipped();
+  // Count non-comment lines once (used by totalRules below). Doing this with a
+  // single loop avoids the .filter().length pattern that allocates a throwaway
+  // array. Callers that want totalDomainsSkipped should call
+  // getTotalDomainsSkipped() from ./domain-cache directly.
+  let finalRuleCount = 0;
+  for (let i = 0; i < filteredOutputLines.length; i++) {
+    if (!filteredOutputLines[i].startsWith('!')) finalRuleCount++;
+  }
 
   return {
     success: mainSuccess && logSuccess,
     outputFile,
     adblockRulesLogFile,
     successfulPageLoads,
-    totalRules: filteredOutputLines.filter(line => !line.startsWith('!')).length, 
+    totalRules: finalRuleCount,
     filteredOutCount,
     totalLines: filteredOutputLines.length,
     outputLines: outputFile ? null : filteredOutputLines // Only return lines if not written to file
-    // Note: totalDomainsSkipped statistic is now available via getTotalDomainsSkipped() 
-    // and doesn't need to be passed through the output handler
   };
 }