@fanboynz/network-scanner 2.0.27 → 2.0.29

package/.clauderc

@@ -0,0 +1,30 @@
+{
+  "description": "Network scanner that monitors website requests and generates blocking rules. Uses Puppeteer to load sites, intercepts network traffic, matches patterns, and outputs rules in various formats (adblock, dnsmasq, hosts file, etc.).",
+  
+  "conventions": [
+    "Store modular functionality in ./lib/ directory with focused, single-purpose modules",
+    "Use messageColors and formatLogMessage from ./lib/colorize for consistent console output",
+    "Implement timeout protection for all Puppeteer operations using Promise.race patterns",
+    "Handle browser lifecycle with comprehensive cleanup in try-finally blocks",
+    "Validate all external tool availability before use (grep, curl, whois, dig)",
+    "Use forceDebug flag for detailed logging, silentMode for minimal output"
+  ],
+  
+  "files": {
+    "important": [
+      "nwss.js",
+      "config.json",
+      "lib/*.js",
+      "*.md",
+      "nwss.1"
+    ],
+    "ignore": [
+      "node_modules/**",
+      "logs/**",
+      "sources/**",
+      ".cache/**",
+      "*.log",
+      "*.gz"
+    ]
+  }
+}

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 };
   }
 }