@fanboynz/network-scanner 1.0.35

package/lib/colorize.js

@@ -0,0 +1,168 @@
+// === Color Utility Module (colorize.js) ===
+// Centralized color management for nwss.js console output
+// Provides consistent theming across all modules
+
+/**
+ * Detects if color output should be enabled based on command line arguments
+ * @returns {boolean} True if --color or --colour flag is present
+ */
+function shouldEnableColors() {
+  return process.argv.includes('--color') || process.argv.includes('--colour');
+}
+
+// Initialize color support based on command line flags
+const enableColors = shouldEnableColors();
+
+/**
+ * ANSI color codes object
+ * Only contains actual escape sequences if colors are enabled
+ */
+const colors = {
+  // Reset and formatting
+  reset: enableColors ? '\x1b[0m' : '',
+  bright: enableColors ? '\x1b[1m' : '',
+  dim: enableColors ? '\x1b[2m' : '',
+  
+  // Standard colors
+  red: enableColors ? '\x1b[31m' : '',
+  green: enableColors ? '\x1b[32m' : '',
+  yellow: enableColors ? '\x1b[33m' : '',
+  blue: enableColors ? '\x1b[34m' : '',
+  magenta: enableColors ? '\x1b[35m' : '',
+  cyan: enableColors ? '\x1b[36m' : '',
+  white: enableColors ? '\x1b[37m' : '',
+  
+  // Extended colors
+  gray: enableColors ? '\x1b[90m' : '',
+  brightRed: enableColors ? '\x1b[91m' : '',
+  brightGreen: enableColors ? '\x1b[92m' : '',
+  brightYellow: enableColors ? '\x1b[93m' : '',
+  brightBlue: enableColors ? '\x1b[94m' : '',
+  brightMagenta: enableColors ? '\x1b[95m' : '',
+  brightCyan: enableColors ? '\x1b[96m' : '',
+  brightWhite: enableColors ? '\x1b[97m' : ''
+};
+
+/**
+ * Applies color formatting to text if colors are enabled
+ * @param {string} text - The text to colorize
+ * @param {string} color - The ANSI color code to apply
+ * @returns {string} Colored text (or plain text if colors disabled)
+ */
+function colorize(text, color) {
+  return enableColors ? `${color}${text}${colors.reset}` : text;
+}
+
+/**
+ * Pre-built color functions for common message types
+ * These provide semantic coloring for different types of console output
+ */
+const messageColors = {
+  // Status and logging
+  debug: (text) => colorize(text, colors.gray),
+  info: (text) => colorize(text, colors.blue),
+  warn: (text) => colorize(text, colors.yellow),
+  error: (text) => colorize(text, colors.red),
+  success: (text) => colorize(text, colors.green),
+  
+  // Process states
+  scanning: (text) => colorize(text, colors.yellow),
+  loaded: (text) => colorize(text, colors.green),
+  processing: (text) => colorize(text, colors.cyan),
+  match: (text) => colorize(text, colors.green),
+  blocked: (text) => colorize(text, colors.red),
+  
+  // Special emphasis
+  highlight: (text) => colorize(text, colors.brightCyan),
+  emphasis: (text) => colorize(text, colors.bright),
+  timing: (text) => colorize(text, colors.cyan),
+  
+  // File operations
+  fileOp: (text) => colorize(text, colors.magenta),
+  compression: (text) => colorize(text, colors.cyan)
+};
+
+/**
+ * Creates a colored tag with consistent formatting
+ * Used for status tags like [debug], [info], [warn], etc.
+ * @param {string} tag - The tag text (without brackets)
+ * @param {string} color - The color to apply
+ * @returns {string} Formatted colored tag
+ */
+function createTag(tag, color) {
+  return colorize(`[${tag}]`, color);
+}
+
+/**
+ * Pre-built tags for common log levels
+ */
+const tags = {
+  debug: createTag('debug', colors.gray),
+  info: createTag('info', colors.blue),
+  warn: createTag('warn', colors.yellow),
+  error: createTag('error', colors.red),
+  match: createTag('match', colors.green),
+  compare: createTag('compare', colors.blue)
+};
+
+/**
+ * Formats a complete log message with colored tag and message
+ * @param {string} tag - The tag name (debug, info, warn, error, etc.)
+ * @param {string} message - The message content
+ * @returns {string} Formatted log message
+ */
+function formatLogMessage(tag, message) {
+  const coloredTag = tags[tag] || createTag(tag, colors.white);
+  return `${coloredTag} ${message}`;
+}
+
+/**
+ * Utility function to check if colors are currently enabled
+ * @returns {boolean} Current color enable status
+ */
+function isColorEnabled() {
+  return enableColors;
+}
+
+/**
+ * Creates a rainbow effect for special messages (like completion)
+ * @param {string} text - Text to apply rainbow effect to
+ * @returns {string} Text with rainbow coloring (if colors enabled)
+ */
+function rainbow(text) {
+  if (!enableColors || text.length === 0) return text;
+  
+  const rainbowColors = [
+    colors.red, colors.yellow, colors.green, 
+    colors.cyan, colors.blue, colors.magenta
+  ];
+  
+  return text
+    .split('')
+    .map((char, index) => {
+      const colorIndex = index % rainbowColors.length;
+      return `${rainbowColors[colorIndex]}${char}`;
+    })
+    .join('') + colors.reset;
+}
+
+module.exports = {
+  // Core functions
+  colorize,
+  colors,
+  
+  // Semantic coloring
+  messageColors,
+  tags,
+  createTag,
+  formatLogMessage,
+  
+  // Utility functions
+  isColorEnabled,
+  shouldEnableColors,
+  rainbow,
+  
+  // Legacy compatibility - keep original function names
+  colorize: colorize,  // Explicit export for backward compatibility
+  colors: colors       // Explicit export for backward compatibility
+};

package/lib/compare.js

@@ -0,0 +1,159 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 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
+ * @param {boolean} forceDebug - Whether to show debug output
+ * @returns {Set<string>} Set of existing rules (normalized)
+ */
+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())
+      .filter(line => line && !line.startsWith('!') && !line.startsWith('#')); // Skip comments and empty lines
+    
+    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();
+      if (normalizedRule) {
+        rules.add(normalizedRule);
+      }
+    }
+    
+    if (forceDebug) {
+      console.log(`[debug] Loaded ${rules.size} comparison rules from ${compareFilePath}`);
+    }
+    
+    return rules;
+  } catch (error) {
+    throw new Error(`Failed to load comparison file: ${error.message}`);
+  }
+}
+
+/**
+ * Normalizes a rule to match the format used in comparison
+ * @param {string} rule - The rule to normalize
+ * @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();
+}
+
+/**
+ * Filters out rules that exist in the comparison set, with smart title handling
+ * @param {Array<string>} rules - Array of rules to filter
+ * @param {Set<string>} comparisonRules - Set of existing rules
+ * @param {boolean} forceDebug - Whether to show debug output
+ * @returns {Array<string>} Filtered rules array
+ */
+function filterUniqueRules(rules, comparisonRules, forceDebug = false) {
+  const result = [];
+  let duplicateCount = 0;
+  let orphanedTitles = 0;
+  
+  // Group rules by titles for smart filtering
+  const groups = [];
+  let currentGroup = { title: null, rules: [] };
+  
+  for (const rule of rules) {
+    if (rule.startsWith('!')) {
+      // Start a new group when we encounter a title
+      if (currentGroup.title !== null || currentGroup.rules.length > 0) {
+        groups.push(currentGroup);
+      }
+      currentGroup = { title: rule, rules: [] };
+    } else {
+      // Add rule to current group
+      currentGroup.rules.push(rule);
+    }
+  }
+  
+  // Don't forget the last group
+  if (currentGroup.title !== null || currentGroup.rules.length > 0) {
+    groups.push(currentGroup);
+  }
+  
+  // Process each group
+  for (const group of groups) {
+    const filteredRules = [];
+    
+    // Filter rules in this group
+    for (const rule of group.rules) {
+      const normalized = normalizeRule(rule);
+      
+      if (!comparisonRules.has(normalized)) {
+        filteredRules.push(rule);
+      } else {
+        duplicateCount++;
+        if (forceDebug) {
+          console.log(`[debug] Filtered duplicate rule: ${rule} (normalized: ${normalized})`);
+        }
+      }
+    }
+    
+    // Only include title if there are remaining rules, or if there's no title (rules without titles)
+    if (group.title && filteredRules.length > 0) {
+      result.push(group.title);
+      result.push(...filteredRules);
+    } else if (!group.title && filteredRules.length > 0) {
+      // Rules without a title - just add them
+      result.push(...filteredRules);
+    } else if (group.title && filteredRules.length === 0) {
+      // Title with no remaining rules - this is an orphaned title
+      orphanedTitles++;
+      if (forceDebug) {
+        console.log(`[debug] Filtered orphaned title: ${group.title} (no unique rules remaining)`);
+      }
+    }
+  }
+  
+  if (forceDebug) {
+    console.log(`[debug] Filtered ${duplicateCount} duplicate rules and ${orphanedTitles} orphaned titles`);
+    console.log(`[debug] ${result.filter(r => !r.startsWith('!')).length} unique rules remaining`);
+  }
+  
+  return result;
+}
+
+module.exports = {
+  loadComparisonRules,
+  normalizeRule,
+  filterUniqueRules
+};

package/lib/compress.js

@@ -0,0 +1,129 @@
+// === Log Compression Utility ===
+// This module provides gzip compression functionality for log files
+
+const fs = require('fs');
+const zlib = require('zlib');
+const path = require('path');
+
+/**
+ * Compresses a file using gzip and optionally removes the original
+ * @param {string} filePath - Path to the file to compress
+ * @param {boolean} removeOriginal - Whether to remove the original file after compression
+ * @returns {Promise<string>} - Path to the compressed file
+ */
+async function compressFile(filePath, removeOriginal = true) {
+  return new Promise((resolve, reject) => {
+    const compressedPath = `${filePath}.gz`;
+    
+    // Create read and write streams
+    const readStream = fs.createReadStream(filePath);
+    const writeStream = fs.createWriteStream(compressedPath);
+    const gzipStream = zlib.createGzip();
+    
+    // Handle errors
+    const handleError = (error) => {
+      // Clean up partial compressed file on error
+      try {
+        if (fs.existsSync(compressedPath)) {
+          fs.unlinkSync(compressedPath);
+        }
+      } catch (cleanupErr) {
+        // Ignore cleanup errors
+      }
+      reject(error);
+    };
+    
+    readStream.on('error', handleError);
+    writeStream.on('error', handleError);
+    gzipStream.on('error', handleError);
+    
+    // Handle successful completion
+    writeStream.on('finish', () => {
+      if (removeOriginal) {
+        try {
+          fs.unlinkSync(filePath);
+        } catch (removeErr) {
+          // If we can't remove original, still consider compression successful
+          console.warn(`[warn] Failed to remove original file ${filePath}: ${removeErr.message}`);
+        }
+      }
+      resolve(compressedPath);
+    });
+    
+    // Pipe the streams
+    readStream.pipe(gzipStream).pipe(writeStream);
+  });
+}
+
+/**
+ * Compresses multiple files and returns results
+ * @param {string[]} filePaths - Array of file paths to compress
+ * @param {boolean} removeOriginals - Whether to remove original files
+ * @returns {Promise<Object>} - Object with successful and failed compressions
+ */
+async function compressMultipleFiles(filePaths, removeOriginals = true) {
+  const results = {
+    successful: [],
+    failed: []
+  };
+  
+  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'
+        });
+      }
+    } catch (error) {
+      results.failed.push({
+        path: filePath,
+        error: error.message
+      });
+    }
+  }
+  
+  return results;
+}
+
+/**
+ * Gets the compression ratio of a file
+ * @param {string} originalPath - Path to original file
+ * @param {string} compressedPath - Path to compressed file
+ * @returns {number} - Compression ratio (0-1, where 0.5 means 50% of original size)
+ */
+function getCompressionRatio(originalPath, compressedPath) {
+  try {
+    const originalSize = fs.statSync(originalPath).size;
+    const compressedSize = fs.statSync(compressedPath).size;
+    return compressedSize / originalSize;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Formats file size in human readable format
+ * @param {number} bytes - Size in bytes
+ * @returns {string} - Formatted size string
+ */
+function formatFileSize(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+module.exports = {
+  compressFile,
+  compressMultipleFiles,
+  getCompressionRatio,
+  formatFileSize
+};