@fanboynz/network-scanner 2.0.66 → 3.0.1

package/lib/browserexit.js

@@ -7,6 +7,7 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
+const { formatLogMessage, messageColors } = require('./colorize');
 
 // Constants for temp file cleanup
 const CHROME_TEMP_PATHS = [
@@ -21,6 +22,16 @@ const CHROME_TEMP_PATTERNS = [
   /^puppeteer-/
 ];
 
+// Precomputed colored subsystem prefixes — used so debug/temp-cleanup/user-data
+// log lines look the same as the rest of the codebase's colorized output.
+// Previously these were raw template literals like `[debug] [browser] ...`
+// which printed uncolored, while formatLogMessage-routed messages elsewhere
+// in the codebase had colored [debug] tags. That produced inconsistent
+// 'sometimes colored, sometimes not' output in scan logs.
+const BROWSER_TAG = messageColors.fileOp('[browser]');
+const TEMP_CLEANUP_TAG = messageColors.cleanup('[temp-cleanup]');
+const USER_DATA_TAG = messageColors.fileOp('[user-data]');
+
 /**
  * Count and remove matching Chrome/Puppeteer temp entries from a directory using fs
  * @param {string} basePath - Directory to scan
@@ -32,7 +43,7 @@ function cleanTempDir(basePath, forceDebug) {
   try {
     entries = fs.readdirSync(basePath);
   } catch {
-    if (forceDebug) console.log(`[debug] [temp-cleanup] Cannot read ${basePath}`);
+    if (forceDebug) console.log(formatLogMessage('debug', `${TEMP_CLEANUP_TAG} Cannot read ${basePath}`));
     return 0;
   }
 
@@ -47,9 +58,9 @@ function cleanTempDir(basePath, forceDebug) {
     try {
       fs.rmSync(path.join(basePath, entry), { recursive: true, force: true });
       cleaned++;
-      if (forceDebug) console.log(`[debug] [temp-cleanup] Removed ${basePath}/${entry}`);
+      if (forceDebug) console.log(formatLogMessage('debug', `${TEMP_CLEANUP_TAG} Removed ${basePath}/${entry}`));
     } catch (rmErr) {
-      if (forceDebug) console.log(`[debug] [temp-cleanup] Failed to remove ${basePath}/${entry}: ${rmErr.message}`);
+      if (forceDebug) console.log(formatLogMessage('debug', `${TEMP_CLEANUP_TAG} Failed to remove ${basePath}/${entry}: ${rmErr.message}`));
     }
   }
 
@@ -61,17 +72,25 @@ function cleanTempDir(basePath, forceDebug) {
  * @param {Object} options - Cleanup options
  * @param {boolean} options.includeSnapTemp - Whether to clean snap temp directories
  * @param {boolean} options.forceDebug - Whether to output debug logs
- * @param {boolean} options.comprehensive - Whether to perform comprehensive cleanup of all temp locations
+ * @param {boolean} options.comprehensive - Equivalent to includeSnapTemp; kept
+ *   for source compatibility with prior callers that distinguished the two.
+ * @param {boolean} options.verbose - Whether to print a user-facing summary
+ *   (in addition to forceDebug's developer logs)
  * @returns {Object} Cleanup results
  */
 function cleanupChromeTempFiles(options = {}) {
   const {
     includeSnapTemp = false,
     forceDebug = false,
-    comprehensive = false
+    comprehensive = false,
+    verbose = false
   } = options;
 
   try {
+    if (verbose && !forceDebug) {
+      console.log(`${TEMP_CLEANUP_TAG} Scanning Chrome/Puppeteer temporary files...`);
+    }
+
     const paths = comprehensive || includeSnapTemp
       ? CHROME_TEMP_PATHS
       : CHROME_TEMP_PATHS.slice(0, 2); // /tmp and /dev/shm only
@@ -81,56 +100,23 @@ function cleanupChromeTempFiles(options = {}) {
       totalCleaned += cleanTempDir(basePath, forceDebug);
     }
 
-    if (forceDebug) {
-      console.log(`[debug] [temp-cleanup] Cleanup completed (${totalCleaned} items)`);
-    }
-
-    return { success: true, itemsCleaned: totalCleaned };
-  } catch (cleanupErr) {
-    if (forceDebug) {
-      console.log(`[debug] [temp-cleanup] Chrome cleanup error: ${cleanupErr.message}`);
-    }
-    return { success: false, error: cleanupErr.message, itemsCleaned: 0 };
-  }
-}
-
-/**
- * Comprehensive temp file cleanup that checks all known Chrome temp locations
- * @param {Object} options - Cleanup options
- * @param {boolean} options.forceDebug - Whether to output debug logs
- * @param {boolean} options.verbose - Whether to show verbose output
- * @returns {Object} Cleanup results
- */
-function comprehensiveChromeTempCleanup(options = {}) {
-  const { forceDebug = false, verbose = false } = options;
-
-  try {
-    if (verbose && !forceDebug) {
-      console.log(`[temp-cleanup] Scanning Chrome/Puppeteer temporary files...`);
-    }
-
-    let totalCleaned = 0;
-    for (const basePath of CHROME_TEMP_PATHS) {
-      totalCleaned += cleanTempDir(basePath, forceDebug);
-    }
-
-    if (verbose && totalCleaned > 0) {
-      console.log(`[temp-cleanup] Removed ${totalCleaned} temporary file(s)/folder(s)`);
-    } else if (verbose && totalCleaned === 0) {
-      console.log(`[temp-cleanup] Clean - no remaining temporary files`);
+    if (verbose) {
+      console.log(totalCleaned > 0
+        ? `${TEMP_CLEANUP_TAG} Removed ${totalCleaned} temporary file(s)/folder(s)`
+        : `${TEMP_CLEANUP_TAG} Clean - no remaining temporary files`);
     } else if (forceDebug) {
-      console.log(`[debug] [temp-cleanup] Comprehensive cleanup completed (${totalCleaned} items)`);
+      console.log(formatLogMessage('debug', `${TEMP_CLEANUP_TAG} Cleanup completed (${totalCleaned} items)`));
     }
 
     return { success: true, itemsCleaned: totalCleaned };
-  } catch (err) {
-    const errorMsg = `Comprehensive temp file cleanup failed: ${err.message}`;
+  } catch (cleanupErr) {
+    const errorMsg = `Chrome temp cleanup failed: ${cleanupErr.message}`;
     if (verbose) {
-      console.warn(`[temp-cleanup] ${errorMsg}`);
+      console.warn(`${TEMP_CLEANUP_TAG} ${errorMsg}`);
     } else if (forceDebug) {
-      console.log(`[debug] [temp-cleanup] ${errorMsg}`);
+      console.log(formatLogMessage('debug', `${TEMP_CLEANUP_TAG} ${errorMsg}`));
     }
-    return { success: false, error: err.message, itemsCleaned: 0 };
+    return { success: false, error: cleanupErr.message, itemsCleaned: 0 };
   }
 }
 
@@ -145,26 +131,21 @@ async function cleanupUserDataDir(userDataDir, forceDebug = false) {
     return { success: true, cleaned: false, reason: 'No user data directory specified' };
   }
 
+  // fs.rmSync({force: true}) treats ENOENT as a no-op, so an existsSync
+  // pre-check is two syscalls where one would do (and a TOCTOU besides).
+  // If the dir was already gone we just report cleaned:true without drama.
   try {
-    
-    if (!fs.existsSync(userDataDir)) {
-      if (forceDebug) {
-        console.log(`[debug] [user-data] User data directory does not exist: ${userDataDir}`);
-      }
-      return { success: true, cleaned: false, reason: 'Directory does not exist' };
-    }
-
     fs.rmSync(userDataDir, { recursive: true, force: true });
-    
+
     if (forceDebug) {
-      console.log(`[debug] [user-data] Cleaned user data directory: ${userDataDir}`);
+      console.log(formatLogMessage('debug', `${USER_DATA_TAG} Cleaned user data directory: ${userDataDir}`));
     }
-    
+
     return { success: true, cleaned: true };
-    
+
   } catch (rmErr) {
     if (forceDebug) {
-      console.log(`[debug] [user-data] Failed to remove user data directory ${userDataDir}: ${rmErr.message}`);
+      console.log(formatLogMessage('debug', `${USER_DATA_TAG} Failed to remove user data directory ${userDataDir}: ${rmErr.message}`));
     }
     return { success: false, error: rmErr.message, cleaned: false };
   }
@@ -178,20 +159,20 @@ async function cleanupUserDataDir(userDataDir, forceDebug = false) {
  */
 async function gracefulBrowserCleanup(browser, forceDebug = false) {
   // FIX: Check browser connection before operations
-  if (!browser || !browser.isConnected()) {
-    if (forceDebug) console.log(`[debug] [browser] Browser not connected, skipping cleanup`);
+  if (!browser || !browser.connected) {
+    if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Browser not connected, skipping cleanup`));
     return;
   }
-  if (forceDebug) console.log(`[debug] [browser] Getting all browser pages...`);
+  if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Getting all browser pages...`));
   let pages;
   try {
     pages = await browser.pages();
   } catch (pagesErr) {
-    if (forceDebug) console.log(`[debug] [browser] Failed to get pages: ${pagesErr.message}`);
+    if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Failed to get pages: ${pagesErr.message}`));
     return;
   }
-  if (forceDebug) console.log(`[debug] [browser] Found ${pages.length} pages to close`);
-  
+  if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Found ${pages.length} pages to close`));
+
   await Promise.all(pages.map(async (page) => {
     if (!page.isClosed()) {
       try {
@@ -202,29 +183,29 @@ async function gracefulBrowserCleanup(browser, forceDebug = false) {
         } catch (urlErr) {
           // Page closed between check and url call
         }
-        
-        if (forceDebug) console.log(`[debug] [browser] Closing page: ${pageUrl}`);
+
+        if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Closing page: ${pageUrl}`));
         await page.close();
-        if (forceDebug) console.log(`[debug] [browser] Page closed successfully`);
+        if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Page closed successfully`));
       } catch (err) {
         // Force close if normal close fails
-        if (forceDebug) console.log(`[debug] [browser] Force closing page: ${err.message}`);
+        if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Force closing page: ${err.message}`));
       }
     }
   }));
-  
-  if (forceDebug) console.log(`[debug] [browser] All pages closed, closing browser...`);
-  
+
+  if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} All pages closed, closing browser...`));
+
   // FIX: Check browser is still connected before closing
   try {
-    if (browser.isConnected()) {
+    if (browser.connected) {
       await browser.close();
-      if (forceDebug) console.log(`[debug] [browser] Browser closed successfully`);
+      if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Browser closed successfully`));
     } else {
-      if (forceDebug) console.log(`[debug] [browser] Browser already disconnected`);
+      if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Browser already disconnected`));
     }
   } catch (closeErr) {
-    if (forceDebug) console.log(`[debug] [browser] Browser close failed: ${closeErr.message}`);
+    if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Browser close failed: ${closeErr.message}`));
   }
 }
 
@@ -236,115 +217,131 @@ async function gracefulBrowserCleanup(browser, forceDebug = false) {
  */
 async function forceBrowserKill(browser, forceDebug = false) {
   try {
-    if (forceDebug) console.log(`[debug] [browser] Attempting force closure of browser process...`);
-    
+    if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Attempting force closure of browser process...`));
+
     const browserProcess = browser.process();
     if (!browserProcess || !browserProcess.pid) {
-      if (forceDebug) console.log(`[debug] [browser] No browser process available`);
+      if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} No browser process available`));
       return;
     }
 
     const mainPid = browserProcess.pid;
-    if (forceDebug) console.log(`[debug] [browser] Main Chrome PID: ${mainPid}`);
+    if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Main Chrome PID: ${mainPid}`));
 
-    // Find and kill ALL related Chrome processes    
-    
+    // PRIMARY PATH: kill OUR browser process tree only.
+    //
+    // The previous primary path ran `ps | grep "puppeteer.*chrome"` and
+    // SIGTERM'd every match, which kills puppeteer-chrome processes spawned
+    // by ANY other process on the machine (concurrent nwss runs, automate
+    // scripts, other tools). The fix is to walk the live process table once
+    // and filter to PIDs whose ancestor chain leads back to OUR mainPid.
+    // The broad sweep stays as the fallback only if ps fails or the targeted
+    // kill doesn't take down the main PID.
+    let killedTargeted = false;
     try {
-      // Find all Chrome processes with puppeteer in command line
-      const psCmd = `ps -eo pid,cmd | grep "puppeteer.*chrome" | grep -v grep`;
-      const psOutput = execSync(psCmd, { encoding: 'utf8', timeout: 5000 });
-      const lines = psOutput.trim().split('\n').filter(line => line.trim());
-      
-      const pidsToKill = [];
-      
-      for (const line of lines) {
-        const match = line.trim().match(/^\s*(\d+)/);
-        if (match) {
-          const pid = parseInt(match[1]);
-          if (!isNaN(pid)) {
-            pidsToKill.push(pid);
-          }
+      const psOutput = execSync(`ps -eo pid,ppid,cmd`, { encoding: 'utf8', timeout: 5000 });
+      const psLines = psOutput.trim().split('\n').slice(1); // drop header
+
+      // pid -> ppid map for ancestry walks; collect chrome-ish candidates.
+      const ppidOf = new Map();
+      const chromeCandidates = new Set();
+      for (const line of psLines) {
+        const m = line.trim().match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+        if (!m) continue;
+        const pid = parseInt(m[1], 10);
+        const ppid = parseInt(m[2], 10);
+        if (Number.isNaN(pid) || Number.isNaN(ppid)) continue;
+        ppidOf.set(pid, ppid);
+        // Chrome's helpers (gpu, renderer, utility) don't all carry the
+        // 'puppeteer' substring; rely on ancestry instead of cmd matching.
+        // 'chrom' covers both 'chrome' and 'chromium' in one substring scan.
+        if (m[3].includes('chrom')) {
+          chromeCandidates.add(pid);
         }
       }
-      
+
+      // Filter candidates to descendants of (or equal to) mainPid.
+      const ourPids = [mainPid];
+      for (const pid of chromeCandidates) {
+        if (pid === mainPid) continue;
+        let cur = ppidOf.get(pid);
+        let hops = 0;
+        while (cur && cur > 1 && hops < 128) {
+          if (cur === mainPid) { ourPids.push(pid); break; }
+          cur = ppidOf.get(cur);
+          hops++;
+        }
+      }
+
       if (forceDebug) {
-        console.log(`[debug] [browser] Found ${pidsToKill.length} Chrome processes to kill: [${pidsToKill.join(', ')}]`);
+        console.log(formatLogMessage('debug', `${BROWSER_TAG} Targeted kill: ${ourPids.length} PIDs in mainPid=${mainPid}'s tree: [${ourPids.join(', ')}]`));
       }
-      
-      // Kill all processes with SIGTERM first (graceful)
-      for (const pid of pidsToKill) {
-        try {
-          process.kill(pid, 'SIGTERM');
-          if (forceDebug) console.log(`[debug] [browser] Sent SIGTERM to PID ${pid}`);
-        } catch (killErr) {
-          if (forceDebug) console.log(`[debug] [browser] Failed to send SIGTERM to PID ${pid}: ${killErr.message}`);
+
+      // SIGTERM the tree gracefully.
+      for (const pid of ourPids) {
+        try { process.kill(pid, 'SIGTERM'); }
+        catch (killErr) {
+          if (forceDebug && killErr.code !== 'ESRCH') {
+            console.log(formatLogMessage('debug', `${BROWSER_TAG} SIGTERM to PID ${pid} failed: ${killErr.message}`));
+          }
         }
       }
-      
-      // Wait for graceful termination
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      
-      // Force kill any remaining processes with SIGKILL
-      for (const pid of pidsToKill) {
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      // SIGKILL stragglers.
+      for (const pid of ourPids) {
         try {
-          // Check if process still exists using signal 0
-          process.kill(pid, 0);
-          // If we reach here, process still exists - force kill it
+          process.kill(pid, 0); // existence probe
           process.kill(pid, 'SIGKILL');
-          if (forceDebug) console.log(`[debug] [browser] Force killed PID ${pid} with SIGKILL`);
+          if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Force-killed PID ${pid}`));
         } catch (checkErr) {
-          // Process already dead (ESRCH error is expected and good)
           if (forceDebug && checkErr.code !== 'ESRCH') {
-            console.log(`[debug] [browser] Error checking/killing PID ${pid}: ${checkErr.message}`);
+            console.log(formatLogMessage('debug', `${BROWSER_TAG} Probe/kill PID ${pid} error: ${checkErr.message}`));
           }
         }
       }
 
-      // Final verification - check if any processes are still alive
-      if (forceDebug) {
-        try {
-          const verifyCmd = `ps -eo pid,cmd | grep "puppeteer.*chrome" | grep -v grep | wc -l`;
-          const remainingCount = execSync(verifyCmd, { encoding: 'utf8', timeout: 2000 }).trim();
-          console.log(`[debug] [browser] Remaining Chrome processes after cleanup: ${remainingCount}`);
-        } catch (verifyErr) {
-          console.log(`[debug] [browser] Could not verify process cleanup: ${verifyErr.message}`);
-        }
-      }
-      
+      // Confirm mainPid is gone — if not, the targeted kill is considered
+      // not-effective and we fall through to the broad sweep below.
+      try { process.kill(mainPid, 0); }
+      catch (e) { if (e.code === 'ESRCH') killedTargeted = true; }
     } catch (psErr) {
-      // Fallback to original method if ps command fails
-      if (forceDebug) console.log(`[debug] [browser] ps command failed, using fallback method: ${psErr.message}`);
-      
+      if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} ps -eo pid,ppid,cmd failed: ${psErr.message}`));
+    }
+
+    // FALLBACK PATH: targeted kill failed or ps wasn't available. Try the
+    // spawned-process handle directly, then last-resort the broad pkill.
+    // (killAllPuppeteerChrome in the next module is the truly nuclear option.)
+    if (!killedTargeted) {
+      if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Targeted kill did not confirm mainPid death; trying browserProcess handle`));
       try {
         browserProcess.kill('SIGTERM');
         await new Promise(resolve => setTimeout(resolve, 2000));
-        
-        // Check if main process still exists and force kill if needed
         try {
-          process.kill(mainPid, 0); // Check existence
-          browserProcess.kill('SIGKILL'); // Force kill if still alive
-          if (forceDebug) console.log(`[debug] [browser] Fallback: Force killed main PID ${mainPid}`);
+          process.kill(mainPid, 0);
+          browserProcess.kill('SIGKILL');
+          if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Fallback: Force-killed main PID ${mainPid}`));
         } catch (checkErr) {
           if (forceDebug && checkErr.code !== 'ESRCH') {
-            console.log(`[debug] [browser] Fallback check error for PID ${mainPid}: ${checkErr.message}`);
+            console.log(formatLogMessage('debug', `${BROWSER_TAG} Fallback probe PID ${mainPid} error: ${checkErr.message}`));
           }
         }
       } catch (fallbackErr) {
-        if (forceDebug) console.log(`[debug] [browser] Fallback kill failed: ${fallbackErr.message}`);
+        if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Fallback kill failed: ${fallbackErr.message}`));
       }
     }
-    
+
   } catch (forceKillErr) {
-    console.error(`[error] [browser] Failed to force kill browser: ${forceKillErr.message}`);
+    console.error(formatLogMessage('error', `${BROWSER_TAG} Failed to force kill browser: ${forceKillErr.message}`));
   }
-  
+
   try {
-    if (browser.isConnected()) {
+    if (browser.connected) {
       browser.disconnect();
-      if (forceDebug) console.log(`[debug] [browser] Browser connection disconnected`);
+      if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Browser connection disconnected`));
     }
   } catch (disconnectErr) {
-    if (forceDebug) console.log(`[debug] [browser] Failed to disconnect browser: ${disconnectErr.message}`);
+    if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Failed to disconnect browser: ${disconnectErr.message}`));
   }
 }
 
@@ -354,22 +351,22 @@ async function forceBrowserKill(browser, forceDebug = false) {
  * @returns {Promise<void>}
  */
 async function killAllPuppeteerChrome(forceDebug = false) {
-  try {    
-    if (forceDebug) console.log(`[debug] [browser] Nuclear option: killing all puppeteer Chrome processes...`);
-    
+  try {
+    if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Nuclear option: killing all puppeteer Chrome processes...`));
+
     try {
       execSync(`pkill -f "puppeteer.*chrome"`, { stdio: 'ignore', timeout: 5000 });
-      if (forceDebug) console.log(`[debug] [browser] pkill completed`);
+      if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} pkill completed`));
     } catch (pkillErr) {
       if (forceDebug && pkillErr.status !== 1) {
-        console.log(`[debug] [browser] pkill failed with status ${pkillErr.status}: ${pkillErr.message}`);
+        console.log(formatLogMessage('debug', `${BROWSER_TAG} pkill failed with status ${pkillErr.status}: ${pkillErr.message}`));
       }
     }
-    
+
     await new Promise(resolve => setTimeout(resolve, 2000));
-    
+
   } catch (nuclearErr) {
-    console.error(`[error] [browser] Nuclear Chrome kill failed: ${nuclearErr.message}`);
+    console.error(formatLogMessage('error', `${BROWSER_TAG} Nuclear Chrome kill failed: ${nuclearErr.message}`));
   }
 }
 
@@ -397,11 +394,16 @@ async function handleBrowserExit(browser, options = {}) {
     verbose = false
   } = options;
   
-  if (forceDebug) console.log(`[debug] [browser] Starting comprehensive browser cleanup...`);
+  if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Starting comprehensive browser cleanup...`));
   
+  // All fields declared upfront so step 3 doesn't extend the object shape at
+  // runtime (V8 hidden-class transition); the result shape is also fully
+  // documented in one place this way.
   const results = {
     browserClosed: false,
     tempFilesCleanedCount: 0,
+    tempFilesCleanedSuccess: false,
+    tempFilesCleanedComprehensive: false,
     userDataCleaned: false,
     success: false,
     errors: []
@@ -410,31 +412,46 @@ async function handleBrowserExit(browser, options = {}) {
   try {
     // Step 1: Browser process cleanup
     try {
-      // Race cleanup against timeout
+      // Race cleanup against a timeout. Attach a no-op .catch to the racing
+      // cleanup promise so that when the timeout wins the eventual rejection
+      // from the still-running graceful cleanup (page.close / browser.close
+      // failing after we move on to forceBrowserKill) doesn't surface as an
+      // unhandledRejection warning.
+      const cleanupPromise = gracefulBrowserCleanup(browser, forceDebug);
+      cleanupPromise.catch(() => {});
       await Promise.race([
-        gracefulBrowserCleanup(browser, forceDebug),
-        new Promise((_, reject) => 
+        cleanupPromise,
+        new Promise((_, reject) =>
           setTimeout(() => reject(new Error('Browser cleanup timeout')), timeout)
         )
       ]);
-      
+
       results.browserClosed = true;
-      
+
     } catch (browserCloseErr) {
       results.errors.push(`Browser cleanup failed: ${browserCloseErr.message}`);
-      
+
       if (forceDebug || verbose) {
-        console.warn(`[warn] [browser] Browser cleanup had issues: ${browserCloseErr.message}`);
+        console.warn(formatLogMessage('warn', `${BROWSER_TAG} Browser cleanup had issues: ${browserCloseErr.message}`));
       }
-      
-      // Attempt force kill
+
+      // Attempt targeted force kill of OUR process tree.
       await forceBrowserKill(browser, forceDebug);
 
-      // Nuclear option if force kill didn't work
-      if (forceDebug) console.log(`[debug] [browser] Attempting nuclear cleanup...`);
-      await killAllPuppeteerChrome(forceDebug);
-      
-      results.browserClosed = true; // Assume success after nuclear option
+      // Only escalate to the broad pkill if our browser is still up. A
+      // successful targeted kill breaks the CDP WebSocket, which flips
+      // isConnected() to false — in that case the nuclear path would just
+      // murder other people's puppeteer-chrome instances for no gain.
+      let stillConnected = false;
+      try { stillConnected = browser.connected; } catch (_) {}
+      if (stillConnected) {
+        if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Targeted force kill didn't take — escalating to nuclear cleanup`));
+        await killAllPuppeteerChrome(forceDebug);
+      } else if (forceDebug) {
+        console.log(formatLogMessage('debug', `${BROWSER_TAG} Targeted force kill succeeded; skipping nuclear cleanup`));
+      }
+
+      results.browserClosed = true; // Assume success after force/nuclear path
     }
     
     // Step 2: User data directory cleanup
@@ -446,31 +463,24 @@ async function handleBrowserExit(browser, options = {}) {
       }
     }
     
-    // Step 3: Temp file cleanup
+    // Step 3: Temp file cleanup. Both branches of the prior code ended up
+    // walking all three CHROME_TEMP_PATHS (comprehensive used all 3 directly;
+    // standard set includeSnapTemp:true which expands to all 3 too) — the
+    // only meaningful difference was the verbose summary log. One call now.
     if (cleanTempFiles) {
-      if (comprehensiveCleanup) {
-        const tempResult = await comprehensiveChromeTempCleanup({ forceDebug, verbose });
-        results.tempFilesCleanedSuccess = tempResult.success;
-        results.tempFilesCleanedComprehensive = true;
-        
-        if (tempResult.success) {
-          results.tempFilesCleanedCount = tempResult.itemsCleaned;
-        } else {
-          results.errors.push(`Comprehensive temp cleanup failed: ${tempResult.error}`);
-        }
+      const tempResult = await cleanupChromeTempFiles({
+        includeSnapTemp: true,
+        comprehensive: comprehensiveCleanup,
+        forceDebug,
+        verbose
+      });
+      results.tempFilesCleanedSuccess = tempResult.success;
+      results.tempFilesCleanedComprehensive = comprehensiveCleanup;
+
+      if (tempResult.success) {
+        results.tempFilesCleanedCount = tempResult.itemsCleaned;
       } else {
-        const tempResult = await cleanupChromeTempFiles({ 
-          includeSnapTemp: true, 
-          forceDebug,
-          comprehensive: false 
-        });
-        results.tempFilesCleanedSuccess = tempResult.success;
-        
-        if (tempResult.success) {
-          results.tempFilesCleanedCount = tempResult.itemsCleaned;
-        } else {
-          results.errors.push(`Standard temp cleanup failed: ${tempResult.error}`);
-        }
+        results.errors.push(`${comprehensiveCleanup ? 'Comprehensive' : 'Standard'} temp cleanup failed: ${tempResult.error}`);
       }
     }
     
@@ -479,23 +489,24 @@ async function handleBrowserExit(browser, options = {}) {
                      (results.errors.length === 0 || !exitOnFailure);
     
     if (forceDebug) {
-      console.log(`[debug] [browser] Cleanup completed - Browser: ${results.browserClosed}, ` +
-                  `Temp files: ${results.tempFilesCleanedCount || 0}, ` +
-                  `User data: ${results.userDataCleaned}, ` +
-                  `Errors: ${results.errors.length}`);
+      console.log(formatLogMessage('debug',
+        `${BROWSER_TAG} Cleanup completed - Browser: ${results.browserClosed}, ` +
+        `Temp files: ${results.tempFilesCleanedCount || 0}, ` +
+        `User data: ${results.userDataCleaned}, ` +
+        `Errors: ${results.errors.length}`));
     }
-    
+
     return results;
-    
+
   } catch (overallErr) {
     results.errors.push(`Overall cleanup failed: ${overallErr.message}`);
     results.success = false;
-    
+
     if (exitOnFailure) {
-      if (forceDebug) console.log(`[debug] [browser] Forcing process exit due to cleanup failure`);
+      if (forceDebug) console.log(formatLogMessage('debug', `${BROWSER_TAG} Forcing process exit due to cleanup failure`));
       process.exit(1);
     }
-    
+
     return results;
   }
 }
@@ -506,7 +517,6 @@ module.exports = {
   forceBrowserKill,
   killAllPuppeteerChrome,
   cleanupChromeTempFiles,
-  comprehensiveChromeTempCleanup,
   cleanupUserDataDir,
   CHROME_TEMP_PATHS,
   CHROME_TEMP_PATTERNS