@fanboynz/network-scanner 2.0.26 → 2.0.28

package/README.md

@@ -281,6 +281,36 @@ These options go at the root level of your config.json:
 | `cache_requests`     | Boolean | `false` | Enable HTTP request response caching |
 
 ---
+#### Special Characters in searchstring
+
+The `searchstring` parameter supports all characters including special symbols. Only double quotes need JSON escaping:
+
+```json
+{
+  "searchstring": [
+    ")}return n}function N(n,e,r){try{\"function\"==typeof",
+    "addEventListener(\"click\",function(){",
+    "{\"status\":\"success\",\"data\":[",
+    "console.log('Debug: ' + value);",
+    "`API endpoint: ${baseUrl}/users`",
+    "@media screen and (max-width: 768px)",
+    "if(e&&e.preventDefault){e.preventDefault()}",
+    "__webpack_require__(/*! ./module */ \"./src/module.js\")",
+    "console.log('Hello world')",
+    "#header { background-color: #ff0000; }",
+    "$(document).ready(function() {",
+    "completion: 85% @ $1,500 budget",
+    "SELECT * FROM users WHERE id = *",
+    "regex: ^[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,}$",
+    "typeof window !== 'undefined'"
+  ]
+}
+```
+
+**Character escaping rules:**
+- `"` becomes `\"` (required in JSON)
+- `\` becomes `\\` (if searching for literal backslashes)
+- All other characters are used literally: `'` `` ` `` `@` `#` `$` `%` `*` `^` `[` `]` `{` `}` `(` `)` `;` `=` `!` `?` `:`
 
 ## Usage Examples
 

package/lib/browserhealth.js

@@ -33,6 +33,18 @@ const PAGE_IDLE_THRESHOLD = 25000; // 25 seconds of inactivity before considerin
 async function performGroupWindowCleanup(browserInstance, groupDescription, forceDebug, cleanupMode = true) {
   try {
     // Wait before cleanup to allow any final operations to complete
+    // Initialize result object with ALL possible properties upfront for V8 optimization
+    const result = {
+      success: false,
+      closedCount: 0,
+      totalPages: 0,
+      mainPagePreserved: false,
+      delayUsed: 0,
+      estimatedMemoryFreed: 0,
+      estimatedMemoryFreedFormatted: '',
+      cleanupMode: '',
+      error: null
+    };
     const modeText = cleanupMode === "all" ? "aggressive cleanup of old windows" : "conservative cleanup of extra windows"
     if (forceDebug) {
       console.log(formatLogMessage('debug', `[group_window_cleanup] Waiting ${WINDOW_CLEANUP_DELAY_MS}ms before ${modeText} for group: ${groupDescription}`));
@@ -47,8 +59,9 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
     
     // Find the main page - typically the first page that's about:blank or has been there longest
     for (const page of allPages) {
-      const url = page.url();
-      if (url === 'about:blank' || url === '' || url.startsWith('chrome://')) {
+      // Cache page.url() call to avoid repeated DOM/browser communication
+      const pageUrl = page.url();
+      if (pageUrl === 'about:blank' || pageUrl === '' || pageUrl.startsWith('chrome://')) {
         if (!mainPuppeteerPage) {
           mainPuppeteerPage = page; // First blank page is likely the main window
         } else {
@@ -56,6 +69,9 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
         }
       } else {
         // Any page with actual content should be evaluated for closure
+        // Cache page state checks to avoid multiple browser calls
+        const isPageClosed = page.isClosed();
+
         if (cleanupMode === "all") {
           // Aggressive mode: close all content pages
           pagesToClose.push(page);
@@ -75,7 +91,9 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
       mainPuppeteerPage = allPages[0]; // Fallback to first page
       pagesToClose = allPages.slice(1);
       if (forceDebug) {
-        console.log(formatLogMessage('debug', `[group_window_cleanup] No blank page found, using first page as main: ${mainPuppeteerPage.url()}`));
+        // Cache URL call for logging
+        const mainPageUrl = mainPuppeteerPage.url();
+        console.log(formatLogMessage('debug', `[group_window_cleanup] No blank page found, using first page as main: ${mainPageUrl}`));
       }
     }
     
@@ -83,14 +101,11 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
       if (forceDebug) {
         console.log(formatLogMessage('debug', `[group_window_cleanup] No windows to close for group: ${groupDescription}`));
       }
-      return { 
-        success: true, 
-        closedCount: 0, 
-        totalPages: allPages.length, 
-        estimatedMemoryFreed: 0,
-        mainPagePreserved: true,
-        cleanupMode: cleanupMode === "all" ? "all" : "default"
-      };
+      result.success = true;
+      result.totalPages = allPages.length;
+      result.mainPagePreserved = true;
+      result.cleanupMode = cleanupMode === "all" ? "all" : "default";
+      return result;
     }
     
     // Estimate memory usage before closing
@@ -102,7 +117,9 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
       let pageMemoryEstimate = 0;
       
       try {
-        if (!page.isClosed()) {
+        // Cache page.isClosed() check to avoid repeated browser calls
+        const isPageClosed = page.isClosed();
+        if (!isPageClosed) {
           // Get page metrics if available
           const metrics = await Promise.race([
             page.metrics(),
@@ -138,12 +155,15 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
     // Close identified old/unused pages
     const closePromises = pagesToClose.map(async (page, index) => {
       try {
-        if (!page.isClosed()) {
+        // Cache page state and URL for this operation
+        const isPageClosed = page.isClosed();
+        const pageUrl = page.url();
+        if (!isPageClosed) {
           if (forceDebug) {
-            console.log(formatLogMessage('debug', `[group_window_cleanup] Closing page: ${page.url()}`));
+            console.log(formatLogMessage('debug', `[group_window_cleanup] Closing page: ${pageUrl}`));
           }
           await page.close();
-          return { success: true, url: page.url() || `page-${index}`, estimatedMemory: pageMemoryEstimates[index] };
+          return { success: true, url: pageUrl || `page-${index}`, estimatedMemory: pageMemoryEstimates[index] };
         }
         return { success: false, reason: 'already_closed', estimatedMemory: 0 };
       } catch (closeErr) {
@@ -177,25 +197,39 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
       console.log(formatLogMessage('debug', `[group_window_cleanup] Closed ${successfulCloses}/${pagesToClose.length} old windows for completed group: ${groupDescription} after ${WINDOW_CLEANUP_DELAY_MS}ms delay`));
       console.log(formatLogMessage('debug', `[group_window_cleanup] Estimated memory freed: ${formatMemory(actualMemoryFreed)}`));
       if (mainPuppeteerPage) {
-        console.log(formatLogMessage('debug', `[group_window_cleanup] Main Puppeteer window preserved: ${mainPuppeteerPage.url()}`));
+        // Cache URL for final logging
+        const mainPageUrl = mainPuppeteerPage.url();
+        console.log(formatLogMessage('debug', `[group_window_cleanup] Main Puppeteer window preserved: ${mainPageUrl}`));
       }
     }
     
-    return { 
-      success: true, 
-      closedCount: successfulCloses,
-      totalPages: allPages.length,
-      mainPagePreserved: mainPuppeteerPage && !mainPuppeteerPage.isClosed(),
-      delayUsed: WINDOW_CLEANUP_DELAY_MS,
-      estimatedMemoryFreed: actualMemoryFreed,
-      estimatedMemoryFreedFormatted: formatMemory(actualMemoryFreed),
-      cleanupMode: cleanupMode === "all" ? "all" : "default"
-    };
+    // Update result object instead of creating new one
+    result.success = true;
+    result.closedCount = successfulCloses;
+    result.totalPages = allPages.length;
+    result.mainPagePreserved = mainPuppeteerPage && !mainPuppeteerPage.isClosed();
+    result.delayUsed = WINDOW_CLEANUP_DELAY_MS;
+    result.estimatedMemoryFreed = actualMemoryFreed;
+    result.estimatedMemoryFreedFormatted = formatMemory(actualMemoryFreed);
+    result.cleanupMode = cleanupMode === "all" ? "all" : "default";
+    return result;
   } catch (cleanupErr) {
     if (forceDebug) {
       console.log(formatLogMessage('debug', `[group_window_cleanup] Group cleanup failed for ${groupDescription}: ${cleanupErr.message}`));
     }
-    return { success: false, error: cleanupErr.message, estimatedMemoryFreed: 0 };
+    // Initialize result object with consistent shape for error case
+    const result = {
+      success: false,
+      closedCount: 0,
+      totalPages: 0,
+      mainPagePreserved: false,
+      delayUsed: 0,
+      estimatedMemoryFreed: 0,
+      estimatedMemoryFreedFormatted: '',
+      cleanupMode: '',
+      error: cleanupErr.message
+    };
+    return result;
   }
 }
 
@@ -207,14 +241,17 @@ async function performGroupWindowCleanup(browserInstance, groupDescription, forc
  */
 async function isPageSafeToClose(page, forceDebug) {
   try {
-    if (page.isClosed()) {
+    // Cache page.isClosed() to avoid repeated browser communication
+    const isPageClosed = page.isClosed();
+    if (isPageClosed) {
       return true; // Already closed
     }
 
   // EXTRA SAFETY: Never close pages that might be in injection process
   try {
-    const url = page.url();
-    if (url && url !== 'about:blank' && Date.now() - (pageCreationTracker.get(page) || 0) < 30000) {
+    // Cache page.url() for safety checks
+    const pageUrl = page.url();
+    if (pageUrl && pageUrl !== 'about:blank' && Date.now() - (pageCreationTracker.get(page) || 0) < 30000) {
       return false; // Don't close recently created pages (within 30 seconds)
     }
   } catch (err) { /* ignore */ }
@@ -228,7 +265,9 @@ async function isPageSafeToClose(page, forceDebug) {
     // Check if page is actively processing
     if (usage.isProcessing) {
       if (forceDebug) {
-        console.log(formatLogMessage('debug', `[realtime_cleanup] Page still processing: ${page.url().substring(0, 50)}...`));
+        // Cache URL for debug logging
+        const pageUrl = page.url();
+        console.log(formatLogMessage('debug', `[realtime_cleanup] Page still processing: ${pageUrl.substring(0, 50)}...`));
       }
       return false;
     }
@@ -257,7 +296,9 @@ async function isPageSafeToClose(page, forceDebug) {
  */
 function updatePageUsage(page, isProcessing = false) {
   try {
-    if (!page.isClosed()) {
+    // Cache page.isClosed() to avoid repeated calls
+    const isPageClosed = page.isClosed();
+    if (!isPageClosed) {
       pageUsageTracker.set(page, {
         lastActivity: Date.now(),
         isProcessing: isProcessing
@@ -281,12 +322,27 @@ async function performRealtimeWindowCleanup(browserInstance, threshold = REALTIM
   try {
     const allPages = await browserInstance.pages();
     
+    // Initialize result object with consistent shape
+    const result = {
+      success: false,
+      closedCount: 0,
+      totalPages: 0,
+      remainingPages: 0,
+      threshold: 0,
+      cleanupDelay: 0,
+      reason: '',
+      error: null
+    };
+    
     // Skip cleanup if we don't have enough pages to warrant it
     if (allPages.length <= Math.max(threshold, REALTIME_CLEANUP_MIN_PAGES)) {
       if (forceDebug) {
         console.log(formatLogMessage('debug', `[realtime_cleanup] Only ${allPages.length} pages open, threshold is ${threshold} - no cleanup needed`));
       }
-      return { success: true, closedCount: 0, totalPages: allPages.length, reason: 'below_threshold' };
+      result.success = true;
+      result.totalPages = allPages.length;
+      result.reason = 'below_threshold';
+      return result;
     }
 
     // Use the provided total delay (already includes appropriate buffer)
@@ -324,13 +380,18 @@ async function performRealtimeWindowCleanup(browserInstance, threshold = REALTIM
     
     // Find main Puppeteer page (usually about:blank)
     let mainPage = allPagesAfterDelay.find(page => {
-      const url = page.url();
-      return url === 'about:blank' || url === '' || url.startsWith('chrome://');
+      // Cache page.url() for main page detection
+      const pageUrl = page.url();
+      return pageUrl === 'about:blank' || pageUrl === '' || pageUrl.startsWith('chrome://');
     }) || allPagesAfterDelay[0]; // Fallback to first page
 
     // Get pages sorted by creation time (oldest first)
     const sortedPages = allPagesAfterDelay
-      .filter(page => page !== mainPage && !page.isClosed())
+      .filter(page => {
+        // Cache page.isClosed() for filtering
+        const isPageClosed = page.isClosed();
+        return page !== mainPage && !isPageClosed;
+      })
       .sort((a, b) => {
         const timeA = pageCreationTracker.get(a) || 0;
         const timeB = pageCreationTracker.get(b) || 0;
@@ -360,15 +421,21 @@ async function performRealtimeWindowCleanup(browserInstance, threshold = REALTIM
           `${pagesToClose.length} pages still active`;
         console.log(formatLogMessage('debug', `[realtime_cleanup] No pages need closing (${reason})`));
       }
-      return { success: true, closedCount: 0, totalPages: allPagesAfterDelay.length, reason: 'no_cleanup_needed' };
+      result.success = true;
+      result.totalPages = allPagesAfterDelay.length;
+      result.reason = 'no_cleanup_needed';
+      return result;
     }
 
     // Close oldest pages
     let closedCount = 0;
     for (const page of safePagesToClose) {
       try {
-        if (!page.isClosed()) {
-          const pageUrl = page.url();
+        // Cache both page state and URL for this iteration
+        const isPageClosed = page.isClosed();
+        const pageUrl = page.url();
+        
+        if (!isPageClosed) {
           await page.close();
           pageCreationTracker.delete(page); // Remove from tracker
           closedCount++;
@@ -390,20 +457,30 @@ async function performRealtimeWindowCleanup(browserInstance, threshold = REALTIM
       console.log(formatLogMessage('debug', `[realtime_cleanup] Closed ${closedCount}/${pagesToClose.length} oldest pages (${unsafePagesCount} skipped for safety), ${remainingPages} pages remaining`));
     }
 
-    return { 
-      success: true, 
-      closedCount, 
-      totalPages: allPagesAfterDelay.length,
-      remainingPages,
-      threshold,
-      cleanupDelay,
-      reason: 'cleanup_completed'
-    };
+    result.success = true;
+    result.closedCount = closedCount;
+    result.totalPages = allPagesAfterDelay.length;
+    result.remainingPages = remainingPages;
+    result.threshold = threshold;
+    result.cleanupDelay = cleanupDelay;
+    result.reason = 'cleanup_completed';
+    return result;
   } catch (cleanupErr) {
     if (forceDebug) {
       console.log(formatLogMessage('debug', `[realtime_cleanup] Cleanup failed: ${cleanupErr.message}`));
     }
-    return { success: false, error: cleanupErr.message, closedCount: 0 };
+    // Initialize result object with consistent shape for error case
+    const result = {
+      success: false,
+      closedCount: 0,
+      totalPages: 0,
+      remainingPages: 0,
+      threshold: 0,
+      cleanupDelay: 0,
+      reason: '',
+      error: cleanupErr.message
+    };
+    return result;
   }
 }
 
@@ -415,14 +492,15 @@ async function performRealtimeWindowCleanup(browserInstance, threshold = REALTIM
  */
 async function isPageFromPreviousScan(page, forceDebug) {
   try {
-    const url = page.url();
+    // Cache page.url() for all checks in this function
+    const pageUrl = page.url();
     
     // Always consider these as old/closeable
-    if (url === 'about:blank' || 
-        url === '' || 
-        url.startsWith('chrome://') ||
-        url.startsWith('chrome-error://') ||
-        url.startsWith('data:')) {
+    if (pageUrl === 'about:blank' || 
+        pageUrl === '' || 
+        pageUrl.startsWith('chrome://') ||
+        pageUrl.startsWith('chrome-error://') ||
+        pageUrl.startsWith('data:')) {
       return false; // Don't close blank pages here, handled separately
     }
     
@@ -446,7 +524,9 @@ async function isPageFromPreviousScan(page, forceDebug) {
     return false; // Conservative - don't close unless we're sure
   } catch (err) {
     if (forceDebug) {
-      console.log(formatLogMessage('debug', `[isPageFromPreviousScan] Error evaluating page ${page.url()}: ${err.message}`));
+      // Cache URL for error logging
+      const pageUrl = page.url();
+      console.log(formatLogMessage('debug', `[isPageFromPreviousScan] Error evaluating page ${pageUrl}: ${err.message}`));
     }
     return false; // Conservative - don't close if we can't evaluate
   }
@@ -1003,7 +1083,9 @@ async function isBrowserHealthy(browserInstance, includeNetworkTest = true) {
  */
 async function cleanupPageBeforeReload(page, forceDebug = false) {
   try {
-    if (page.isClosed()) {
+    // Cache page.isClosed() to avoid repeated browser calls
+    const isPageClosed = page.isClosed();
+    if (isPageClosed) {
       return false;
     }
 

package/lib/cdp.js

@@ -27,6 +27,31 @@
 
 const { formatLogMessage } = require('./colorize');
 
+/**
+ * Creates a reusable timeout promise to reduce function allocation overhead
+ * @param {number} ms - Timeout in milliseconds
+ * @param {string} message - Error message for timeout
+ * @returns {Promise} Promise that rejects after timeout
+ */
+function createTimeoutPromise(ms, message) {
+  return new Promise((_, reject) => 
+    setTimeout(() => reject(new Error(message)), ms)
+  );
+}
+
+/**
+ * Creates a standardized session result object for consistent V8 optimization
+ * @param {object|null} session - CDP session or null
+ * @param {Function} cleanup - Cleanup function
+ * @param {boolean} isEnhanced - Whether enhanced features are active
+ * @returns {object} Standardized session object
+ */
+const createSessionResult = (session = null, cleanup = async () => {}, isEnhanced = false) => ({
+  session,
+  cleanup,
+  isEnhanced
+});
+
 /**
  * Creates a new page with timeout protection to prevent CDP hangs
  * @param {import('puppeteer').Browser} browser - Browser instance
@@ -36,9 +61,7 @@ const { formatLogMessage } = require('./colorize');
 async function createPageWithTimeout(browser, timeout = 30000) {
   return Promise.race([
     browser.newPage(),
-    new Promise((_, reject) => 
-      setTimeout(() => reject(new Error('Page creation timeout - browser may be unresponsive')), timeout)
-    )
+    createTimeoutPromise(timeout, 'Page creation timeout - browser may be unresponsive')
   ]);
 }
 
@@ -52,9 +75,7 @@ async function setRequestInterceptionWithTimeout(page, timeout = 15000) {
   try {
     await Promise.race([
       page.setRequestInterception(true),
-      new Promise((_, reject) => 
-        setTimeout(() => reject(new Error('Request interception timeout - first attempt')), timeout)
-      )
+      createTimeoutPromise(timeout, 'Request interception timeout - first attempt')
     ]);
   } catch (firstError) {
     // Check for immediate critical failures
@@ -68,9 +89,7 @@ async function setRequestInterceptionWithTimeout(page, timeout = 15000) {
     try {
       await Promise.race([
         page.setRequestInterception(true),
-        new Promise((_, reject) => 
-          setTimeout(() => reject(new Error('Request interception timeout - retry failed')), timeout * 2)
-        )
+        createTimeoutPromise(timeout * 2, 'Request interception timeout - retry failed')
       ]);
     } catch (retryError) {
       if (retryError.message.includes('Network.enable timed out') || 
@@ -128,7 +147,7 @@ async function createCDPSession(page, currentUrl, options = {}) {
   
   if (!cdpLoggingNeeded) {
     // Return a null session with no-op cleanup for consistent API
-    return { session: null, cleanup: async () => {} };
+    return createSessionResult();
   }
 
   // Log which CDP mode is being used
@@ -151,9 +170,7 @@ async function createCDPSession(page, currentUrl, options = {}) {
     // Add timeout protection for CDP session creation
     cdpSession = await Promise.race([
       page.createCDPSession(),
-      new Promise((_, reject) => 
-        setTimeout(() => reject(new Error('CDP session creation timeout')), 20000)
-      )
+      createTimeoutPromise(20000, 'CDP session creation timeout')
     ]);
     
     // Enable network domain - required for network event monitoring  
@@ -166,19 +183,17 @@ async function createCDPSession(page, currentUrl, options = {}) {
       const initiator = params.initiator ? params.initiator.type : 'unknown';
       
       // Extract hostname for logging context (handles URL parsing errors gracefully)
-      let hostnameForLog = 'unknown-host';
-      try {
-        const currentHostname = new URL(currentUrl).hostname;
-        const requestHostname = new URL(requestUrl).hostname;
-        // Show both hostnames if different (cross-domain requests)
-        if (currentHostname !== requestHostname) {
-          hostnameForLog = `${currentHostname}?${requestHostname}`;
-        } else {
-          hostnameForLog = currentHostname;
+      const hostnameForLog = (() => {
+        try {
+          const currentHostname = new URL(currentUrl).hostname;
+          const requestHostname = new URL(requestUrl).hostname;
+          return currentHostname !== requestHostname 
+            ? `${currentHostname}?${requestHostname}`
+            : currentHostname;
+        } catch (_) { 
+          return 'unknown-host';
         }
-      } catch (_) { 
-        // Ignore URL parsing errors for logging context
-      }
+      })();
       
  // Log the request with context only if debug mode is enabled
  if (forceDebug) {
@@ -207,7 +222,8 @@ async function createCDPSession(page, currentUrl, options = {}) {
             }
           }
         }
-      }
+      },
+      isEnhanced: false
     };
 
   } catch (cdpErr) {
@@ -218,7 +234,7 @@ async function createCDPSession(page, currentUrl, options = {}) {
       try {
         return new URL(currentUrl).hostname;
       } catch {
-        return currentUrl.substring(0, 50) + '...';
+        return `${currentUrl.substring(0, 50)}...`;
       }
     })();
 
@@ -239,10 +255,7 @@ async function createCDPSession(page, currentUrl, options = {}) {
     console.warn(formatLogMessage('warn', `[cdp] Failed to attach CDP session for ${currentUrl}: ${cdpErr.message}`));
     
     // Return null session with no-op cleanup for consistent API
-    return {
-      session: null,
-      cleanup: async () => {}
-    };
+    return createSessionResult();
   }
 }
 
@@ -278,17 +291,25 @@ function validateCDPConfig(siteConfig, globalCDP, cdpSpecificDomains = []) {
       warnings.push('cdp_specific is empty - no domains will have CDP enabled');
     } else {
       // Validate domain format
-      const invalidDomains = siteConfig.cdp_specific.filter(domain => {
-        return typeof domain !== 'string' || domain.trim() === '';
-      });
-      if (invalidDomains.length > 0) {
+      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
-  if (globalCDP || siteConfig.cdp === true || (siteConfig.cdp_specific && siteConfig.cdp_specific.length > 0)) {
+  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) {
@@ -332,7 +353,8 @@ async function createEnhancedCDPSession(page, currentUrl, options = {}) {
   const basicSession = await createCDPSession(page, currentUrl, options);
   
   if (!basicSession.session) {
-    return basicSession;
+    // Ensure enhanced flag is set even for null sessions
+    return { ...basicSession, isEnhanced: false };
   }
 
   const { session } = basicSession;
@@ -377,7 +399,7 @@ async function createEnhancedCDPSession(page, currentUrl, options = {}) {
     
     // Graceful degradation: return basic session if enhanced features fail
     // This ensures your application continues working even if advanced features break
-    return basicSession;
+    return { ...basicSession, isEnhanced: false };
   }
 }
 

package/lib/nettools.js

@@ -111,7 +111,7 @@ function execWithTimeout(command, timeout = 10000) {
  * @param {string} mode - Selection mode: 'random' (default) or 'cycle'
  * @returns {string|null} Selected whois server or null if none specified
  */
-function selectWhoisServer(whoisServer, mode = 'random'){
+function selectWhoisServer(whoisServer = '', mode = 'random'){
   if (!whoisServer) {
     return null; // Use default whois behavior
   }
@@ -201,7 +201,7 @@ function suggestWhoisServers(domain, failedServer = null) {
  * @param {boolean} debugMode - Enable debug logging (default: false)
  * @returns {Promise<Object>} Object with success status and output/error
  */
-async function whoisLookup(domain, timeout = 10000, whoisServer = null, debugMode = false, logFunc = null) {
+async function whoisLookup(domain = '', timeout = 10000, whoisServer = '', debugMode = false, logFunc = null) {
   const startTime = Date.now();
   let cleanDomain, selectedServer, whoisCommand;
   
@@ -357,7 +357,7 @@ async function whoisLookup(domain, timeout = 10000, whoisServer = null, debugMod
  * @param {number} whoisDelay - Delay in milliseconds before whois requests (default: 2000)
  * @returns {Promise<Object>} Object with success status and output/error
  */
-async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null, debugMode = false, retryOptions = {}, whoisDelay = 4000, logFunc = null) {
+async function whoisLookupWithRetry(domain = '', timeout = 10000, whoisServer = '', debugMode = false, retryOptions = {}, whoisDelay = 8000, logFunc = null) {
   const {
     maxRetries = 3,
     timeoutMultiplier = 1.5,
@@ -367,184 +367,240 @@ async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null,
   } = retryOptions;
 
   let serversToTry = [];
-  let currentTimeout = timeout;
   
   // Build list of servers to try
-  if (whoisServer) {
+  if (whoisServer && whoisServer !== '') {
     if (Array.isArray(whoisServer)) {
       serversToTry = [...whoisServer]; // Copy array to avoid modifying original
     } else {
       serversToTry = [whoisServer];
     }
   } else {
-    serversToTry = [null]; // Default server
+    serversToTry = ['']; // Default server (empty string instead of null)
   }
   
   // Add fallback servers if enabled and we have custom servers
-  if (useFallbackServers && whoisServer) {
+  if (useFallbackServers && whoisServer && whoisServer !== '') {
     const fallbacks = suggestWhoisServers(domain).slice(0, 3);
     // Only add fallbacks that aren't already in our list
-    const existingServers = serversToTry.filter(s => s !== null);
-    const newFallbacks = fallbacks.filter(fb => !existingServers.includes(fb));
+    const existingServers = serversToTry.filter(s => s !== '');
+        const existingServerCount = existingServers.length;
+        const newFallbacks = fallbacks.filter(fb => {
+          for (let i = 0; i < existingServerCount; i++) {
+            if (existingServers[i] === fb) return false;
+          }
+          return true;
+        });
     serversToTry.push(...newFallbacks);
   }
   
   let lastError = null;
-  let attemptCount = 0;
+  let totalAttempts = 0;
+  let serversAttempted = [];
   
   if (debugMode) {
+      const totalServers = serversToTry.length;
     if (logFunc) {
-      logFunc(`${messageColors.highlight('[whois-retry]')} Starting whois lookup for ${domain} with ${serversToTry.length} server(s) to try`);
+        logFunc(`${messageColors.highlight('[whois-retry]')} Starting whois lookup for ${domain} with ${totalServers} server(s) to try`);
       logFunc(`${messageColors.highlight('[whois-retry]')} Servers: [${serversToTry.map(s => s || 'default').join(', ')}]`);
-      logFunc(`${messageColors.highlight('[whois-retry]')} Retry settings: maxRetries=${maxRetries}, timeoutMultiplier=${timeoutMultiplier}, retryOnTimeout=${retryOnTimeout}, retryOnError=${retryOnError}`);
+      logFunc(`${messageColors.highlight('[whois-retry]')} Retry settings: maxRetries=${maxRetries} per server, timeoutMultiplier=${timeoutMultiplier}, retryOnTimeout=${retryOnTimeout}, retryOnError=${retryOnError}`);
     } else {
-      console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Starting whois lookup for ${domain} with ${serversToTry.length} server(s) to try`));
+        console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Starting whois lookup for ${domain} with ${totalServers} server(s) to try`));
       console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Servers: [${serversToTry.map(s => s || 'default').join(', ')}]`));
-      console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Retry settings: maxRetries=${maxRetries}, timeoutMultiplier=${timeoutMultiplier}, retryOnTimeout=${retryOnTimeout}, retryOnError=${retryOnError}`));
+      console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Retry settings: maxRetries=${maxRetries} per server, timeoutMultiplier=${timeoutMultiplier}, retryOnTimeout=${retryOnTimeout}, retryOnError=${retryOnError}`));
     }
   }
   
-  for (const server of serversToTry) {
-    attemptCount++;
+  // Try each server with retry logic
+  const serverCount = serversToTry.length;
+  for (let serverIndex = 0; serverIndex < serverCount; serverIndex++) {
+    const server = serversToTry[serverIndex];
+    let currentTimeout = timeout;
+    let retryCount = 0;
+    serversAttempted.push(server);
     
     if (debugMode) {
-      const serverName = server || 'default';
+      const serverName = (server && server !== '') ? server : 'default';
       if (logFunc) {
-        logFunc(`${messageColors.highlight('[whois-retry]')} Attempt ${attemptCount}/${serversToTry.length}: trying server ${serverName} (timeout: ${currentTimeout}ms)`);
+        logFunc(`${messageColors.highlight('[whois-retry]')} Server ${serverIndex + 1}/${serverCount}: ${serverName} (max ${maxRetries} attempts)`);
       } else {
-        console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Attempt ${attemptCount}/${serversToTry.length}: trying server ${serverName} (timeout: ${currentTimeout}ms)`));
+        console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Server ${serverIndex + 1}/${serverCount}: ${serverName} (max ${maxRetries} attempts)`));
       }
     }
     
-    // Add delay between retry attempts to prevent rate limiting
-    if (attemptCount > 1) {
-      if (whoisDelay > 0) {
-        if (debugMode) {
-          if (logFunc) {
-            logFunc(`${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay before retry attempt...`);
-          } else {
-            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay before retry attempt...`));
-          }
-        }
-        await new Promise(resolve => setTimeout(resolve, whoisDelay));
-      }
+    // Retry this server up to maxRetries times
+    while (retryCount < maxRetries) {
+      totalAttempts++;
+      const attemptNum = retryCount + 1;
       
-    } else if (whoisDelay > 0) {
-      // Add initial delay on first attempt if configured
       if (debugMode) {
+        const serverName = (server && server !== '') ? server : 'default';
         if (logFunc) {
-          logFunc(`${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay to prevent rate limiting...`);
+          logFunc(`${messageColors.highlight('[whois-retry]')} Attempt ${attemptNum}/${maxRetries} on server ${serverName} (timeout: ${currentTimeout}ms)`);
         } else {
-          console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay to prevent rate limiting...`));
+          console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Attempt ${attemptNum}/${maxRetries} on server ${serverName} (timeout: ${currentTimeout}ms)`));
         }
       }
-      await new Promise(resolve => setTimeout(resolve, whoisDelay));
-    } else if (debugMode) {
-      // Log when delay is skipped due to whoisDelay being 0
-      if (logFunc) {
-        logFunc(`${messageColors.highlight('[whois-retry]')} Skipping delay (whoisDelay: ${whoisDelay}ms)`);
-      } else {
-        console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Skipping delay (whoisDelay: ${whoisDelay}ms)`));
-      }
-   }
-    
-    try {
-      const result = await whoisLookup(domain, currentTimeout, server, debugMode, logFunc);
       
-      if (result.success) {
+      // Add progressive delay between retries (but not before first attempt on any server)
+      if (retryCount > 0 && whoisDelay > 0) {
+        // Progressive delay: base delay * retry attempt number + extra delay
+        // Attempt 2: base delay * 1 + 4000ms = 8000ms + 4000ms = 12000ms
+        // Attempt 3: base delay * 2 + 6000ms = 16000ms + 6000ms = 22000ms
+        // Attempt 4+: base delay * 3 + 6000ms = 24000ms + 6000ms = 30000ms (if maxRetries > 3)
+        const delayMultiplier = Math.min(retryCount, 3);
+        const baseDelay = whoisDelay * delayMultiplier;
+        
+        // Add extra delay based on retry attempt
+        let extraDelay = 0;
+        if (retryCount === 1) {
+          extraDelay = 4000; // Extra 4 seconds for 2nd attempt
+        } else if (retryCount >= 2) {
+          extraDelay = 6000; // Extra 6 seconds for 3rd+ attempts
+        }
+        
+        const actualDelay = baseDelay + extraDelay;
+        
+        if (debugMode) {
+          if (logFunc) {
+            logFunc(`${messageColors.highlight('[whois-retry]')} Adding ${actualDelay}ms progressive delay before retry ${retryCount + 1} (base: ${baseDelay}ms + extra: ${extraDelay}ms)...`);
+          } else {
+            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Adding ${actualDelay}ms progressive delay before retry ${retryCount + 1} (base: ${baseDelay}ms + extra: ${extraDelay}ms)...`));
+          }
+        }
+        await new Promise(resolve => setTimeout(resolve, actualDelay));
+      } else if (serverIndex > 0 && retryCount === 0 && whoisDelay > 0) {
+        // Add delay before trying a new server (but not the very first server)
         if (debugMode) {
           if (logFunc) {
-            logFunc(`${messageColors.highlight('[whois-retry]')} SUCCESS on attempt ${attemptCount}/${serversToTry.length} using server ${result.whoisServer || 'default'}`);
+            logFunc(`${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay before trying new server...`);
           } else {
-            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} SUCCESS on attempt ${attemptCount}/${serversToTry.length} using server ${result.whoisServer || 'default'}`));
+            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay before trying new server...`));
           }
         }
+        await new Promise(resolve => setTimeout(resolve, whoisDelay));
+      } else if (debugMode && whoisDelay === 0) {
+        // Log when delay is skipped due to whoisDelay being 0
+        if (logFunc) {
+          logFunc(`${messageColors.highlight('[whois-retry]')} Skipping delay (whoisDelay: ${whoisDelay}ms)`);
+        } else {
+          console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Skipping delay (whoisDelay: ${whoisDelay}ms)`));
+        }
+      }
+      
+      try {
+        const result = await whoisLookup(domain, currentTimeout, server || '', debugMode, logFunc);
         
-        // Add retry info to result
-        return {
-          ...result,
-          retryInfo: {
-            totalAttempts: attemptCount,
-            maxAttempts: serversToTry.length,
-            serversAttempted: serversToTry.slice(0, attemptCount),
-            finalServer: result.whoisServer,
-            retriedAfterFailure: attemptCount > 1
+        if (result.success) {
+          if (debugMode) {
+            if (logFunc) {
+              logFunc(`${messageColors.highlight('[whois-retry]')} SUCCESS on attempt ${attemptNum}/${maxRetries} for server ${result.whoisServer || 'default'} (total attempts: ${totalAttempts})`);
+            } else {
+              console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} SUCCESS on attempt ${attemptNum}/${maxRetries} for server ${result.whoisServer || 'default'} (total attempts: ${totalAttempts})`));
+            }
           }
-        };
-      } else {
+          
+          // Add retry info to result
+          // V8 Optimized: Object.assign performs better than spread
+          return Object.assign({}, result, {
+            retryInfo: {
+              totalAttempts: totalAttempts,
+              maxAttempts: serverCount * maxRetries,
+              serversAttempted: serversAttempted,
+              finalServer: result.whoisServer,
+              retriedAfterFailure: totalAttempts > 1,
+              serverRetries: retryCount,
+              serverIndex: serverIndex
+            }
+          });
+        }
+        
         // Determine if we should retry based on error type
         const shouldRetry = (result.isTimeout && retryOnTimeout) || (!result.isTimeout && retryOnError);
         
         if (debugMode) {
-          const serverName = result.whoisServer || 'default';
+          const serverName = (result.whoisServer && result.whoisServer !== '') ? result.whoisServer : 'default';
           const errorType = result.isTimeout ? 'TIMEOUT' : 'ERROR';
           if (logFunc) {
-            logFunc(`${messageColors.highlight('[whois-retry]')} ${errorType} on attempt ${attemptCount}/${serversToTry.length} with server ${serverName}: ${result.error}`);
+            logFunc(`${messageColors.highlight('[whois-retry]')} ${errorType} on attempt ${attemptNum}/${maxRetries} with server ${serverName}: ${result.error}`);
           } else {
-            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} ${errorType} on attempt ${attemptCount}/${serversToTry.length} with server ${serverName}: ${result.error}`));
+            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} ${errorType} on attempt ${attemptNum}/${maxRetries} with server ${serverName}: ${result.error}`));
           }
           
-          if (attemptCount < serversToTry.length) {
+          if (retryCount < maxRetries - 1) {
             if (shouldRetry) {
               if (logFunc) {
-                logFunc(`${messageColors.highlight('[whois-retry]')} Will retry with next server...`);
+                logFunc(`${messageColors.highlight('[whois-retry]')} Will retry attempt ${attemptNum + 1}/${maxRetries} on same server...`);
               } else {
-                console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Will retry with next server...`));
+                console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Will retry attempt ${attemptNum + 1}/${maxRetries} on same server...`));
               }
             } else {
               if (logFunc) {
-                logFunc(`${messageColors.highlight('[whois-retry]')} Skipping retry (retryOn${result.isTimeout ? 'Timeout' : 'Error'}=${shouldRetry})`);
+                logFunc(`${messageColors.highlight('[whois-retry]')} Skipping retry on same server (retryOn${result.isTimeout ? 'Timeout' : 'Error'}=${shouldRetry})`);
               } else {
-                console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Skipping retry (retryOn${result.isTimeout ? 'Timeout' : 'Error'}=${shouldRetry})`));
+                console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Skipping retry on same server (retryOn${result.isTimeout ? 'Timeout' : 'Error'}=${shouldRetry})`));
               }
             }
+          } else if (serverIndex < serverCount - 1) {
+            if (logFunc) {
+              logFunc(`${messageColors.highlight('[whois-retry]')} Max retries reached for server${serverIndex < serverCount - 1 ? ', will try next server...' : ', no more servers to try'}`);
+            } else {
+              console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Max retries reached for server${serverIndex < serverCount - 1 ? ', will try next server...' : ', no more servers to try'}`));            }
           }
         }
         
         lastError = result;
         
-        // If this is the last server or we shouldn't retry this error type, break
-        if (attemptCount >= serversToTry.length || !shouldRetry) {
+        // If this is the last retry for this server or we shouldn't retry this error type, break to next server
+        if (retryCount >= maxRetries - 1 || !shouldRetry) {
           break;
         }
         
-        // Increase timeout for next attempt
+        // Increase timeout for next retry attempt on same server
+        retryCount++;
         currentTimeout = Math.round(currentTimeout * timeoutMultiplier);
-      }
-    } catch (error) {
-      if (debugMode) {
-        const serverName = server || 'default';
-        if (logFunc) {
-          logFunc(`${messageColors.highlight('[whois-retry]')} EXCEPTION on attempt ${attemptCount}/${serversToTry.length} with server ${serverName}: ${error.message}`);
-        } else {
-          console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} EXCEPTION on attempt ${attemptCount}/${serversToTry.length} with server ${serverName}: ${error.message}`));
+        
+      } catch (error) {
+        if (debugMode) {
+          const serverName = (server && server !== '') ? server : 'default'
+          if (logFunc) {
+            logFunc(`${messageColors.highlight('[whois-retry]')} EXCEPTION on attempt ${attemptNum}/${maxRetries} with server ${serverName}: ${error.message}`);
+          } else {
+            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} EXCEPTION on attempt ${attemptNum}/${maxRetries} with server ${serverName}: ${error.message}`));
+          }
         }
+        
+        lastError = {
+          success: false,
+          error: error.message,
+          domain: domain,
+          whoisServer: server || '',
+          isTimeout: error.message.includes('timeout'),
+          duration: 0
+        };
+        
+        // For exceptions, only retry if it's a retryable error type
+        const isRetryableException = error.message.includes('timeout') || 
+                                   error.message.includes('ECONNRESET') || 
+                                   error.message.includes('ENOTFOUND');
+        
+        if (retryCount >= maxRetries - 1 || !isRetryableException) {
+          break;
+        }
+        
+        retryCount++;
+        currentTimeout = Math.round(currentTimeout * timeoutMultiplier);
       }
-      
-      lastError = {
-        success: false,
-        error: error.message,
-        domain: domain,
-        whoisServer: server,
-        isTimeout: error.message.includes('timeout'),
-        duration: 0
-      };
-      
-      // Continue to next server unless this is the last one
-      if (attemptCount >= serversToTry.length) {
-        break;
-      }
-      
-      currentTimeout = Math.round(currentTimeout * timeoutMultiplier);
     }
   }
   
   // All attempts failed
   if (debugMode) {
+    const attemptedServerCount = serversAttempted.length;
     if (logFunc) {
-      logFunc(`${messageColors.highlight('[whois-retry]')} FINAL FAILURE: All ${attemptCount} attempts failed for ${domain}`);
+      logFunc(`${messageColors.highlight('[whois-retry]')} FINAL FAILURE: All ${totalAttempts} attempts failed for ${domain} across ${attemptedServerCount} server(s)`);
     } else {
-      console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} FINAL FAILURE: All ${attemptCount} attempts failed for ${domain}`));
+      console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} FINAL FAILURE: All ${totalAttempts} attempts failed for ${domain} across ${attemptedServerCount} server(s)`));
     }
     if (lastError) {
       if (logFunc) {
@@ -556,17 +612,17 @@ async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null,
   }
   
   // Return the last error with retry info
-  return {
-    ...lastError,
+  // V8 Optimized: Object.assign instead of spread operator
+  return Object.assign({}, lastError, {
     retryInfo: {
-      totalAttempts: attemptCount,
-      maxAttempts: serversToTry.length,
-      serversAttempted: serversToTry.slice(0, attemptCount),
-      finalServer: lastError?.whoisServer || null,
-      retriedAfterFailure: attemptCount > 1,
+      totalAttempts: totalAttempts,
+      maxAttempts: serverCount * maxRetries,
+      serversAttempted: serversAttempted,
+      finalServer: lastError?.whoisServer || '',
+      retriedAfterFailure: totalAttempts > 1,
       allAttemptsFailed: true
     }
-  };
+  });
 }
 
 /**
@@ -576,7 +632,7 @@ async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null,
  * @param {number} timeout - Timeout in milliseconds (default: 5000)
  * @returns {Promise<Object>} Object with success status and output/error
  */
-async function digLookup(domain, recordType = 'A', timeout = 5000) {
+async function digLookup(domain = '', recordType = 'A', timeout = 5000) {
   try {
     // Clean domain
     const cleanDomain = domain.replace(/^https?:\/\//, '').replace(/\/.*$/, '').replace(/:\d+$/, '');
@@ -826,7 +882,7 @@ function createNetToolsHandler(config) {
       if (forceDebug) {
         logToConsoleAndFile(`${messageColors.highlight('[nettools]')} Overall timeout for domain ${domain}, continuing with next...`);
       }
-    }, 30000); // 30 second overall timeout
+    }, 65000); // 65 second overall timeout
     
     // Wrap entire function in timeout protection
     return Promise.race([
@@ -837,7 +893,7 @@ function createNetToolsHandler(config) {
           clearTimeout(netlookupTimeout);
         }
       })(),
-      new Promise((_, reject) => setTimeout(() => reject(new Error('NetTools overall timeout')), 30000))
+      new Promise((_, reject) => setTimeout(() => reject(new Error('NetTools overall timeout')), 65000))
     ]).catch(err => {
       if (forceDebug) {
         logToConsoleAndFile(`${messageColors.highlight('[nettools]')} ${err.message} for ${domain}, continuing...`);
@@ -904,7 +960,7 @@ function createNetToolsHandler(config) {
         
         // Check whois cache first - cache key includes server for accuracy
         const selectedServer = selectWhoisServer(whoisServer, whoisServerMode);
-        const whoisCacheKey = `${domain}-${selectedServer || 'default'}`;
+        const whoisCacheKey = `${domain}-${(selectedServer && selectedServer !== '') ? selectedServer : 'default'}`;
         const now = Date.now();
         let whoisResult = null;
         
@@ -913,16 +969,15 @@ function createNetToolsHandler(config) {
           if (now - cachedEntry.timestamp < WHOIS_CACHE_TTL) {
             if (forceDebug) {
               const age = Math.round((now - cachedEntry.timestamp) / 1000);
-              const serverInfo = selectedServer ? ` (server: ${selectedServer})` : ' (default server)';
+              const serverInfo = (selectedServer && selectedServer !== '') ? ` (server: ${selectedServer})` : ' (default server)';
               logToConsoleAndFile(`${messageColors.highlight('[whois-cache]')} Using cached result for ${domain}${serverInfo} [age: ${age}s]`);
             }
-            whoisResult = { 
-              ...cachedEntry.result,
-              // Add cache metadata
+            // V8 Optimized: Object.assign is faster than spread for object merging
+            whoisResult = Object.assign({}, cachedEntry.result, {
               fromCache: true,
               cacheAge: now - cachedEntry.timestamp,
               originalTimestamp: cachedEntry.timestamp
-            };
+            });
           } else {
             // Cache expired, remove it
             whoisResultCache.delete(whoisCacheKey);
@@ -935,7 +990,7 @@ function createNetToolsHandler(config) {
         // Perform fresh lookup if not cached
         if (!whoisResult) {
           if (forceDebug) {
-            const serverInfo = selectedServer ? ` using server ${selectedServer}` : ' using default server';
+            const serverInfo = (selectedServer && selectedServer !== '') ? ` using server ${selectedServer}` : ' using default server';
             logToConsoleAndFile(`${messageColors.highlight('[whois]')} Performing fresh whois lookup for ${domain}${serverInfo}`);
           }
         
@@ -1357,4 +1412,4 @@ module.exports = {
   getCommonWhoisServers,
   suggestWhoisServers,
   execWithTimeout // Export for testing
-};
+};

package/nwss.js

@@ -1,4 +1,4 @@
-// === Network scanner script (nwss.js) v2.0.26 ===
+// === Network scanner script (nwss.js) v2.0.27 ===
 
 // puppeteer for browser automation, fs for file system operations, psl for domain parsing.
 // const pLimit = require('p-limit'); // Will be dynamically imported
@@ -143,7 +143,7 @@ const { navigateWithRedirectHandling, handleRedirectTimeout } = require('./lib/r
 const { monitorBrowserHealth, isBrowserHealthy, isQuicklyResponsive, performGroupWindowCleanup, performRealtimeWindowCleanup, trackPageForRealtime, updatePageUsage, cleanupPageBeforeReload } = require('./lib/browserhealth');
 
 // --- Script Configuration & Constants --- 
-const VERSION = '2.0.26'; // Script version
+const VERSION = '2.0.27'; // Script version
 
 // get startTime
 const startTime = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanboynz/network-scanner",
-  "version": "2.0.26",
+  "version": "2.0.28",
   "description": "A Puppeteer-based network scanner for analyzing web traffic, generating adblock filter rules, and identifying third-party requests. Features include fingerprint spoofing, Cloudflare bypass, content analysis with curl/grep, and multiple output formats.",
   "main": "nwss.js",
   "scripts": {