@fanboynz/network-scanner 2.0.66 → 3.0.0

package/lib/clear_sitedata.js

@@ -2,7 +2,8 @@
 // Handles comprehensive site data clearing via CDP and page-level fallbacks
 // Resolves SecurityError issues with localStorage/sessionStorage access
 
-const { formatLogMessage } = require('./colorize');
+const { formatLogMessage, messageColors } = require('./colorize');
+const CLEAR_SITEDATA_TAG = messageColors.processing('[clear_sitedata]');
 
 /**
  * Clears site data using CDP (bypasses same-origin restrictions)
@@ -15,14 +16,23 @@ const { formatLogMessage } = require('./colorize');
 async function clearSiteDataViaCDP(page, currentUrl, forceDebug, quickMode = false) {
   let clearDataSession = null;
   const completedOperations = [];
-  
+
   try {
-    clearDataSession = await Promise.race([
-      page.target().createCDPSession(),
-      new Promise((_, reject) => 
-        setTimeout(() => reject(new Error('CDP session timeout')), 10000)
-      )
-    ]);
+    // Capture the timeout-timer ID so we can clear it once the race
+    // resolves. Previously the setTimeout fired 10s after the success
+    // path completed — reject was swallowed (race already settled)
+    // but the timer kept the event loop reference for up to 10s.
+    let timeoutTimer;
+    const sessionPromise = page.target().createCDPSession();
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutTimer = setTimeout(() => reject(new Error('CDP session timeout')), 10000);
+      if (typeof timeoutTimer.unref === 'function') timeoutTimer.unref();
+    });
+    try {
+      clearDataSession = await Promise.race([sessionPromise, timeoutPromise]);
+    } finally {
+      clearTimeout(timeoutTimer);
+    }
     
     const origin = new URL(currentUrl).origin;
     
@@ -38,7 +48,7 @@ async function clearSiteDataViaCDP(page, currentUrl, forceDebug, quickMode = fal
         completedOperations.push(op.name);
       } catch (opErr) {
         if (forceDebug) {
-          console.log(formatLogMessage('debug', `[clear_sitedata] ${op.name} clear failed: ${opErr.message}`));
+          console.log(formatLogMessage('debug', `${CLEAR_SITEDATA_TAG} ${op.name} clear failed: ${opErr.message}`));
         }
       }
     }
@@ -71,7 +81,7 @@ async function clearSiteDataViaCDP(page, currentUrl, forceDebug, quickMode = fal
             completedOperations.push(storage.name);
           } catch (individualErr) {
             if (forceDebug) {
-              console.log(formatLogMessage('debug', `[clear_sitedata] ${storage.name} clear failed: ${individualErr.message}`));
+              console.log(formatLogMessage('debug', `${CLEAR_SITEDATA_TAG} ${storage.name} clear failed: ${individualErr.message}`));
             }
           }
         }
@@ -79,14 +89,14 @@ async function clearSiteDataViaCDP(page, currentUrl, forceDebug, quickMode = fal
     }
     
     if (forceDebug && completedOperations.length > 0) {
-      console.log(formatLogMessage('debug', `[clear_sitedata] CDP cleared: ${completedOperations.join(', ')}`));
+      console.log(formatLogMessage('debug', `${CLEAR_SITEDATA_TAG} CDP cleared: ${completedOperations.join(', ')}`));
     }
     
     return { success: completedOperations.length > 0, operations: completedOperations };
     
   } catch (cdpErr) {
     if (forceDebug) {
-      console.log(formatLogMessage('debug', `[clear_sitedata] CDP session failed: ${cdpErr.message}`));
+      console.log(formatLogMessage('debug', `${CLEAR_SITEDATA_TAG} CDP session failed: ${cdpErr.message}`));
     }
     return { success: false, operations: completedOperations };
   } finally {
@@ -108,12 +118,21 @@ async function clearSiteDataViaCDP(page, currentUrl, forceDebug, quickMode = fal
  */
 async function clearSiteDataViaPage(page, forceDebug) {
   try {
-    const result = await page.evaluate(() => {
+    // Page-side body is now async so we can `await` the IndexedDB
+    // cleanup chain. Previously it was sync and the indexedDB.databases()
+    // promise was fire-and-forget — cleared.push('indexedDB') ran before
+    // the deletion actually completed, so callers saw 'indexedDB' in the
+    // operations list even though the dbs were still pending deletion
+    // when page.evaluate returned.
+    const result = await page.evaluate(async () => {
       const cleared = [];
-      
+
       // Test and clear localStorage
       try {
         if (window.localStorage && typeof window.localStorage.setItem === 'function') {
+          // setItem+removeItem is a permission probe — throws SecurityError
+          // on some origins before we get to clear(). Don't simplify to
+          // just clear() unless you want to swallow those errors silently.
           const testKey = '__nwss_access_test__';
           localStorage.setItem(testKey, 'test');
           localStorage.removeItem(testKey);
@@ -123,8 +142,8 @@ async function clearSiteDataViaPage(page, forceDebug) {
       } catch (e) {
         // Security error expected on some sites
       }
-      
-      // Test and clear sessionStorage  
+
+      // Test and clear sessionStorage
       try {
         if (window.sessionStorage && typeof window.sessionStorage.setItem === 'function') {
           const testKey = '__nwss_access_test__';
@@ -136,38 +155,40 @@ async function clearSiteDataViaPage(page, forceDebug) {
       } catch (e) {
         // Security error expected on some sites
       }
-      
-      // Clear IndexedDB
+
+      // Clear IndexedDB — actually wait for the deletion chain to
+      // complete before reporting. indexedDB.deleteDatabase returns an
+      // IDBRequest (not a Promise), so wrap each in a Promise that
+      // resolves on success/error/blocked, then Promise.all.
       try {
         if (window.indexedDB && typeof window.indexedDB.databases === 'function') {
-          window.indexedDB.databases().then(dbs => {
-            dbs.forEach(db => {
-              try {
-                window.indexedDB.deleteDatabase(db.name);
-              } catch (dbErr) {
-                // Individual DB deletion may fail
-              }
-            });
-          }).catch(() => {
-            // Database listing may fail
-          });
+          const dbs = await window.indexedDB.databases();
+          await Promise.all(dbs.map(db => new Promise((resolve) => {
+            if (!db.name) return resolve();
+            let req;
+            try { req = window.indexedDB.deleteDatabase(db.name); }
+            catch (_) { return resolve(); }
+            req.onsuccess = () => resolve();
+            req.onerror = () => resolve();   // best-effort — don't fail the batch
+            req.onblocked = () => resolve(); // another tab has it open; can't wait forever
+          })));
           cleared.push('indexedDB');
         }
       } catch (e) {
-        // IndexedDB may not be available
+        // IndexedDB may not be available, or databases() may reject
       }
-      
+
       return cleared;
     });
     
     if (forceDebug && result.length > 0) {
-      console.log(formatLogMessage('debug', `[clear_sitedata] Page-level cleared: ${result.join(', ')}`));
+      console.log(formatLogMessage('debug', `${CLEAR_SITEDATA_TAG} Page-level cleared: ${result.join(', ')}`));
     }
     
     return { success: result.length > 0, operations: result };
   } catch (pageErr) {
     if (forceDebug) {
-      console.log(formatLogMessage('debug', `[clear_sitedata] Page evaluation failed: ${pageErr.message}`));
+      console.log(formatLogMessage('debug', `${CLEAR_SITEDATA_TAG} Page evaluation failed: ${pageErr.message}`));
     }
     return { success: false, operations: [] };
   }
@@ -216,132 +237,13 @@ async function clearSiteData(page, currentUrl, forceDebug, quickMode = false) {
   };
 }
 
-/**
- * Enhanced site data clearing with additional browser-level operations
- * Includes cache warming prevention and comprehensive storage cleanup
- * @param {Page} page - Puppeteer page instance
- * @param {string} currentUrl - URL being processed  
- * @param {boolean} forceDebug - Debug logging flag
- * @returns {Promise<{success: boolean, operations: string[], method: string}>}
- */
-async function clearSiteDataEnhanced(page, currentUrl, forceDebug) {
-  let clearDataSession = null;
-  const completedOperations = [];
-  
-  try {
-    clearDataSession = await Promise.race([
-      page.target().createCDPSession(),
-      new Promise((_, reject) => 
-        setTimeout(() => reject(new Error('Enhanced CDP session timeout')), 15000)
-      )
-    ]);
-    
-    const origin = new URL(currentUrl).origin;
-    
-    // Enhanced clearing operations
-    const enhancedOperations = [
-      // Network layer
-      { cmd: 'Network.clearBrowserCookies', name: 'cookies' },
-      { cmd: 'Network.clearBrowserCache', name: 'cache' },
-      
-      // Storage layer - comprehensive
-      {
-        cmd: 'Storage.clearDataForOrigin',
-        params: { origin, storageTypes: 'all' },
-        name: 'all_storage'
-      },
-      
-      // Runtime layer
-      { cmd: 'Runtime.discardConsoleEntries', name: 'console' },
-      
-      // Security layer
-      { cmd: 'Security.disable', name: 'security_reset' }
-    ];
-    
-    for (const op of enhancedOperations) {
-      try {
-        if (op.params) {
-          await clearDataSession.send(op.cmd, op.params);
-        } else {
-          await clearDataSession.send(op.cmd);
-        }
-        completedOperations.push(op.name);
-      } catch (opErr) {
-        if (forceDebug) {
-          console.log(formatLogMessage('debug', `[clear_sitedata_enhanced] ${op.name} failed: ${opErr.message}`));
-        }
-        
-        // For storage operations, try individual fallbacks
-        if (op.name === 'all_storage') {
-          const individualTypes = ['local_storage', 'session_storage', 'indexeddb', 'websql', 'service_workers'];
-          for (const type of individualTypes) {
-            try {
-              await clearDataSession.send('Storage.clearDataForOrigin', {
-                origin,
-                storageTypes: type
-              });
-              completedOperations.push(type);
-            } catch (individualErr) {
-              // Continue trying other types
-            }
-          }
-        }
-      }
-    }
-    
-    // Additional DOM cleanup via page evaluation
-    try {
-      await page.evaluate(() => {
-        // Clear any cached DOM queries
-        if (window.document && document.querySelectorAll) {
-          // Force garbage collection of cached selectors
-          const div = document.createElement('div');
-          document.body.appendChild(div);
-          document.body.removeChild(div);
-        }
-        
-        // Clear performance entries
-        if (window.performance && performance.clearMarks) {
-          performance.clearMarks();
-          performance.clearMeasures();
-        }
-      });
-      completedOperations.push('dom_cleanup');
-    } catch (domErr) {
-      if (forceDebug) {
-        console.log(formatLogMessage('debug', `[clear_sitedata_enhanced] DOM cleanup failed: ${domErr.message}`));
-      }
-    }
-    
-    if (forceDebug && completedOperations.length > 0) {
-      console.log(formatLogMessage('debug', `[clear_sitedata_enhanced] Cleared: ${completedOperations.join(', ')}`));
-    }
-    
-    return {
-      success: completedOperations.length > 0,
-      operations: completedOperations,
-      method: 'enhanced_CDP'
-    };
-    
-  } catch (enhancedErr) {
-    if (forceDebug) {
-      console.log(formatLogMessage('debug', `[clear_sitedata_enhanced] Failed: ${enhancedErr.message}`));
-    }
-    
-    // Fallback to regular clearing
-    return await clearSiteData(page, currentUrl, forceDebug, false);
-    
-  } finally {
-    if (clearDataSession) {
-      try { 
-        await clearDataSession.detach(); 
-      } catch (detachErr) { 
-        // Ignore detach errors
-      }
-    }
-  }
-}
-
+// Public surface. clearSiteDataViaCDP / clearSiteDataViaPage are
+// internal helpers but exported for testing / advanced callers.
+// (Previously also defined a clearSiteDataEnhanced function that wasn't
+// even exported and had zero callers anywhere — 117 lines of dead code
+// removed, including a mislabeled "Security.disable" CDP call dressed
+// up as "security_reset" that just disabled the CDP Security domain
+// with no actual security effect.)
 module.exports = {
   clearSiteData,
   clearSiteDataViaCDP,