@fanboynz/network-scanner 2.0.20 → 2.0.21

package/nwss.1

@@ -303,7 +303,7 @@ Number of times to reload the page (default: 1).
 
 .TP
 .B forcereload
-Boolean. Force an additional reload after reloads.
+Boolean or Array. Force cache-clearing reload for all URLs or specific domains. Can be \fBtrue\fR/\fBfalse\fR or array of domain names like \fB["domain1.com", "domain2.com"]\fR. When set to \fBtrue\fR, applies to all URLs in the site configuration. When set to an array, applies only to URLs whose domains match the specified domains. Supports exact hostname matching and subdomain matching (e.g., "example.com" matches both "example.com" and "subdomain.example.com"). Domain matching is case-insensitive and automatically handles protocols, ports, and paths.
 
 .TP
 .B timeout
@@ -784,6 +784,37 @@ With default settings (\fBignore_similar_threshold: 80\fR):
 }
 .EE
 
+.SS Force reload examples:
+.EX
+# Force reload for all URLs in a site configuration
+{
+  "url": ["https://site1.com", "https://site2.com"],
+  "filterRegex": "ads|tracking",
+  "forcereload": true
+}
+
+# Force reload only for specific domains
+{
+  "url": [
+    "https://example.com/page1",
+    "https://test.org/page2", 
+    "https://demo.net/page3"
+  ],
+  "filterRegex": "\\\\.(space|website)\\\\b",
+  "forcereload": ["example.com", "demo.net"],
+  "comments": [
+    "Only example.com and demo.net URLs get force reload",
+    "test.org URLs use standard reload"
+  ]
+}
+
+# Mixed configuration with domain-specific force reload
+{
+  "url": "https://cdn.example.com/content/page.html",
+  "forcereload": ["example.com"]
+}
+.EE
+
 .SS Configuration with documentation comments:
 .EX
 {

package/nwss.js

@@ -1,4 +1,4 @@
-// === Network scanner script (nwss.js) v2.0.20 ===
+// === Network scanner script (nwss.js) v2.0.21 ===
 
 // puppeteer for browser automation, fs for file system operations, psl for domain parsing.
 // const pLimit = require('p-limit'); // Will be dynamically imported
@@ -130,7 +130,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.20'; // Script version
+const VERSION = '2.0.21'; // Script version
 
 // get startTime
 const startTime = Date.now();
@@ -516,7 +516,7 @@ Redirect Handling Options:
   interact_intensity: "low"|"medium"|"high"     Interaction simulation intensity (default: medium)
   delay: <milliseconds>                        Delay after load (default: 4000)
   reload: <number>                             Reload page n times after load (default: 1)
-  forcereload: true/false                      Force an additional reload after reloads
+  forcereload: true/false or ["domain1.com", "domain2.com"]  Force cache-clearing reload for all URLs or specific domains
   clear_sitedata: true/false                   Clear all cookies, cache, storage before each load (default: false)
   subDomains: 1/0                              Output full subdomains (default: 0)
   localhost: true/false                        Force localhost output (127.0.0.1)
@@ -3202,7 +3202,80 @@ function setupFrameHandling(page, forceDebug) {
       updatePageUsage(page, true);
 
       const totalReloads = (siteConfig.reload || 1) - 1; // Subtract 1 because initial load counts as first
-      const useForceReload = siteConfig.forcereload === true;
+      
+      // Enhanced forcereload logic: support boolean or domain array
+      let useForceReload = false;
+      if (siteConfig.forcereload === true) {
+        // Original behavior: force reload for all URLs
+        useForceReload = true;
+      } else if (Array.isArray(siteConfig.forcereload)) {
+        // Input validation: filter out invalid entries
+        const validDomains = siteConfig.forcereload.filter(domain => {
+          if (typeof domain !== 'string') {
+            if (forceDebug) {
+              console.log(formatLogMessage('debug', `Invalid forcereload entry (not string): ${typeof domain} - ${JSON.stringify(domain)}`));
+            }
+            return false;
+          }
+          
+          if (domain.trim() === '') {
+            if (forceDebug) {
+              console.log(formatLogMessage('debug', `Invalid forcereload entry (empty string)`));
+            }
+            return false;
+          }
+          
+          return true;
+        });
+        
+        if (validDomains.length === 0) {
+          if (forceDebug) {
+            console.log(formatLogMessage('debug', `No valid domains in forcereload array for ${currentUrl}`));
+          }
+          useForceReload = false;
+        } else {
+        // New behavior: force reload only for matching domains
+        const currentDomain = safeGetDomain(currentUrl, true); // Get full hostname
+        const currentRootDomain = safeGetDomain(currentUrl, false); // Get root domain
+        
+        useForceReload = validDomains.some(domain => {
+          // Enhanced domain cleaning: handle protocols, ports, paths, and normalize case
+          let cleanDomain = domain.trim();
+          cleanDomain = cleanDomain.replace(/^https?:\/\//, '');  // Remove protocol
+          cleanDomain = cleanDomain.replace(/:\d+$/, '');         // Remove port (e.g., :8080)
+          cleanDomain = cleanDomain.replace(/\/.*$/, '');         // Remove path
+          cleanDomain = cleanDomain.toLowerCase();               // Normalize case
+          
+          // Additional validation: basic domain format check
+          if (!/^[a-z0-9.-]+$/.test(cleanDomain)) {
+            if (forceDebug) {
+              console.log(formatLogMessage('debug', `Skipping invalid domain format in forcereload: ${domain} -> ${cleanDomain}`));
+            }
+            return false;
+          }
+          
+          // Check if current URL matches this domain
+          // Support both exact hostname match and subdomain match
+          if (currentDomain.toLowerCase() === cleanDomain || currentRootDomain.toLowerCase() === cleanDomain) {
+            return true;
+          }
+          
+          // Check if current hostname ends with the domain (subdomain match)
+          if (currentDomain.toLowerCase().endsWith('.' + cleanDomain)) {
+            return true;
+          }
+          
+          return false;
+        });
+        }
+        
+        if (forceDebug && useForceReload) {
+          console.log(formatLogMessage('debug', `Force reload enabled for ${currentUrl} - matches domain in forcereload list`));
+        } else if (forceDebug && validDomains.length > 0) {
+          console.log(formatLogMessage('debug', `Force reload not applied for ${currentUrl} - no domain match in [${validDomains.join(', ')}]`));
+        }
+      }
+      // If forcereload is not specified, false, or any other value, useForceReload remains false
       
       if (useForceReload && forceDebug) {
         console.log(formatLogMessage('debug', `Using force reload mechanism for all ${totalReloads + 1} reload(s) on ${currentUrl}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanboynz/network-scanner",
-  "version": "2.0.20",
+  "version": "2.0.21",
   "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": {