@fanboynz/network-scanner 2.0.26 → 2.0.27

package/lib/nettools.js

@@ -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 = null, debugMode = false, retryOptions = {}, whoisDelay = 8000, logFunc = null) {
   const {
     maxRetries = 3,
     timeoutMultiplier = 1.5,
@@ -367,7 +367,6 @@ async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null,
   } = retryOptions;
 
   let serversToTry = [];
-  let currentTimeout = timeout;
   
   // Build list of servers to try
   if (whoisServer) {
@@ -390,88 +389,124 @@ async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null,
   }
   
   let lastError = null;
-  let attemptCount = 0;
+  let totalAttempts = 0;
+  let serversAttempted = [];
   
   if (debugMode) {
     if (logFunc) {
       logFunc(`${messageColors.highlight('[whois-retry]')} Starting whois lookup for ${domain} with ${serversToTry.length} 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]')} 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
+  for (let serverIndex = 0; serverIndex < serversToTry.length; serverIndex++) {
+    const server = serversToTry[serverIndex];
+    let currentTimeout = timeout;
+    let retryCount = 0;
+    serversAttempted.push(server);
     
     if (debugMode) {
       const serverName = 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}/${serversToTry.length}: ${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}/${serversToTry.length}: ${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 || '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
+          return {
+            ...result,
+            retryInfo: {
+              totalAttempts: totalAttempts,
+              maxAttempts: serversToTry.length * 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);
         
@@ -479,72 +514,85 @@ async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null,
           const serverName = 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 < serversToTry.length - 1) {
+            if (logFunc) {
+              logFunc(`${messageColors.highlight('[whois-retry]')} Max retries reached for server, will try next server...`);
+            } else {
+              console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Max retries reached for server, will try next server...`));
+            }
           }
         }
         
         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 || '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) {
     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 ${serversAttempted.length} 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 ${serversAttempted.length} server(s)`));
     }
     if (lastError) {
       if (logFunc) {
@@ -559,11 +607,11 @@ async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null,
   return {
     ...lastError,
     retryInfo: {
-      totalAttempts: attemptCount,
-      maxAttempts: serversToTry.length,
-      serversAttempted: serversToTry.slice(0, attemptCount),
+      totalAttempts: totalAttempts,
+      maxAttempts: serversToTry.length * maxRetries,
+      serversAttempted: serversAttempted,
       finalServer: lastError?.whoisServer || null,
-      retriedAfterFailure: attemptCount > 1,
+      retriedAfterFailure: totalAttempts > 1,
       allAttemptsFailed: true
     }
   };
@@ -1357,4 +1405,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.27",
   "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": {