@fanboynz/network-scanner 2.0.66 → 3.0.0

package/lib/smart-cache.js

@@ -6,11 +6,24 @@
 const { LRUCache } = require('lru-cache');
 const fs = require('fs');
 const path = require('path');
-const { formatLogMessage } = require('./colorize');
+const { formatLogMessage, messageColors } = require('./colorize');
+
+// Precomputed colored '[SmartCache]' subsystem prefix. formatLogMessage only
+// colors the [severity] tag; the '[SmartCache]' substring was sitting plain
+// inside every debug message. Colored once at module load so we don't
+// re-colorize per log call.
+const SMART_CACHE_TAG = messageColors.processing('[SmartCache]');
 
 // Shared frozen empty object -- avoids allocating new {} for every default param
 const EMPTY = Object.freeze({});
 
+// Headers we fold into the request cache key. Hoisted (not built per-call)
+// so _generateRequestCacheKey doesn't allocate a fresh array on every cache
+// op. Frozen because the array is treated as read-only at runtime.
+const REQUEST_CACHE_KEY_HEADERS = Object.freeze([
+  'accept', 'accept-encoding', 'accept-language', 'user-agent'
+]);
+
 /**
  * SmartCache - Intelligent caching system with multiple cache layers
  * @class
@@ -48,21 +61,20 @@ class SmartCache {
     this.saveTimeout = null;
     this.pendingSave = false;
 
-    // Cache hot-path flags BEFORE _initializeCaches uses them
+    // Cache hot-path flags BEFORE _initializeCaches uses them.
     this._debug = this.options.forceDebug;
     this._highConcurrency = this.options.concurrency > 10;
     this._criticalThreshold = this._highConcurrency ? 0.85 : 1.0;
     this._warningThreshold = this._highConcurrency ? 0.70 : 0.85;
     this._infoThreshold = this._highConcurrency ? 0.60 : 0.75;
-    
-    // Initialize cache layers (may disable responseCache for high concurrency)
-    this._initializeCaches();
-
-    // Cache enable flags AFTER _initializeCaches which may modify options
     this._enablePattern = this.options.enablePatternCache;
     this._enableResponse = this.options.enableResponseCache;
     this._enableWhois = this.options.enableWhoisCache;
     this._enableRequest = this.options.enableRequestCache;
+
+    // Initialize cache layers. _initializeCaches may flip this._enableResponse
+    // off for very high concurrency / aggressive mode (and null the LRU).
+    this._initializeCaches();
     
     // Initialize statistics
     this._initializeStats();
@@ -71,12 +83,6 @@ class SmartCache {
     this._lastHeapUsed = 0;
     this._memoryPressure = false;
 
-    
-    // NEW: Clear request cache
-    if (this._enableRequest) {
-      this.clearRequestCache();
-    }
-    
     // Load persistent cache if enabled
     if (this.options.enablePersistence) {
       this._loadPersistentCache();
@@ -136,15 +142,29 @@ class SmartCache {
       ttl: this.options.ttl * 2 // Patterns are more stable
     });
     
-    // Response content cache - aggressive limits for high concurrency
-    const responseCacheSize = this._highConcurrency ? 50 : 200;
-    const responseCacheMemory = this._highConcurrency ? 20 * 1024 * 1024 : 50 * 1024 * 1024;
-    this.responseCache = new LRUCache({
-      max: responseCacheSize,
-      ttl: 1000 * 60 * 30, // 30 minutes for response content
-      maxSize: responseCacheMemory,
-      sizeCalculation: (value) => value.length
-    });
+    // Response content cache - aggressive limits for high concurrency.
+    // Skip allocation entirely when very high concurrency / aggressive mode
+    // would disable it anyway (avoids a dead LRU sitting in memory).
+    const responseCacheDisabled = this.options.concurrency > 15 || this.options.aggressiveMode;
+    if (responseCacheDisabled) {
+      this.options.enableResponseCache = false;
+      this._enableResponse = false;
+      this.responseCache = null;
+      if (this._debug) {
+        console.log(formatLogMessage('debug',
+          `${SMART_CACHE_TAG} Response cache disabled for high concurrency (${this.options.concurrency})`
+        ));
+      }
+    } else {
+      const responseCacheSize = this._highConcurrency ? 50 : 200;
+      const responseCacheMemory = this._highConcurrency ? 20 * 1024 * 1024 : 50 * 1024 * 1024;
+      this.responseCache = new LRUCache({
+        max: responseCacheSize,
+        ttl: 1000 * 60 * 30, // 30 minutes for response content
+        maxSize: responseCacheMemory,
+        sizeCalculation: (value) => value.length
+      });
+    }
 
     // NEW: Request-level cache for --cache-requests feature
     if (this._enableRequest) {
@@ -163,19 +183,9 @@ class SmartCache {
           return size;
         }
       });
-      
-      if (this._debug) {
-        console.log(formatLogMessage('debug', `[SmartCache] Request cache initialized: ${this.options.requestCacheMaxSize} entries`));
-      }
-    }
 
-    // Disable response cache entirely for very high concurrency
-    if (this.options.concurrency > 15 || this.options.aggressiveMode) {
-      this.options.enableResponseCache = false;
       if (this._debug) {
-        console.log(formatLogMessage('debug', 
-          `[SmartCache] Response cache disabled for high concurrency (${this.options.concurrency})`
-        ));
+        console.log(formatLogMessage('debug', `${SMART_CACHE_TAG} Request cache initialized: ${this.options.requestCacheMaxSize} entries`));
       }
     }
 
@@ -194,9 +204,6 @@ class SmartCache {
     
     // Regex compilation cache (bounded to prevent unbounded growth)
     this.regexCache = new LRUCache({ max: 500 });
-    
-    // Precompile the regex-stripping pattern (used in getCompiledRegex)
-    this._regexStripPattern = /^\/(.*)\/$/;
   }
   
   /**
@@ -245,7 +252,7 @@ class SmartCache {
       if (this._debug) {
         const age = Date.now() - cached.timestamp;
         console.log(formatLogMessage('debug', 
-          `[SmartCache] Cache hit for ${domain} (age: ${Math.round(age/1000)}s)`
+          `${SMART_CACHE_TAG} Cache hit for ${domain} (age: ${Math.round(age/1000)}s)`
         ));
       }
       return true;
@@ -273,7 +280,7 @@ class SmartCache {
     
     if (this._debug) {
       console.log(formatLogMessage('debug', 
-        `[SmartCache] Marked ${domain} as processed`
+        `${SMART_CACHE_TAG} Marked ${domain} as processed`
       ));
     }
   }
@@ -349,16 +356,16 @@ class SmartCache {
   _generateRequestCacheKey(url, options = EMPTY, normalizedUrl = null) {
     const method = options.method || 'GET';
     const normUrl = normalizedUrl || this._normalizeUrl(url);
-    const headers = options.headers || {};
-    const importantHeaders = ['accept', 'accept-encoding', 'accept-language', 'user-agent'];
-    
+    const headers = options.headers || EMPTY;
+
     // Build header portion of key by direct concat (avoids JSON.stringify + intermediate array)
     let headerKey = '';
-    for (const header of importantHeaders) {
+    for (let i = 0; i < REQUEST_CACHE_KEY_HEADERS.length; i++) {
+      const header = REQUEST_CACHE_KEY_HEADERS[i];
       const val = headers[header];
       if (val) headerKey += header + '=' + val + '&';
     }
-    
+
     return method + '|' + normUrl + '|' + headerKey;
   }
   
@@ -382,14 +389,26 @@ class SmartCache {
     if (cached) {
       this.stats.requestCacheHits++;
       if (this._debug) {
-        console.log(formatLogMessage('debug', 
-          `[SmartCache] Request cache hit for ${url.substring(0, 50)}... (${cached.status || 'unknown status'})`
+        console.log(formatLogMessage('debug',
+          `${SMART_CACHE_TAG} Request cache hit for ${url.substring(0, 50)}... (${cached.status || 'unknown status'})`
         ));
       }
-      // Set directly on cached object (avoids spread allocation per hit)
-      cached.fromCache = true;
-      cached.cacheAge = Date.now() - cached.timestamp;
-      return cached;
+      // Return a shallow copy with hit-time metadata. Mutating the live LRU
+      // entry races on cacheAge with concurrent readers and lets a caller
+      // accidentally corrupt the shared body/headers. The copy costs an
+      // object allocation per hit -- worth it for the safety.
+      return {
+        timestamp: cached.timestamp,
+        status: cached.status,
+        statusText: cached.statusText,
+        headers: cached.headers,
+        body: cached.body,
+        url: cached.url,
+        originalUrl: cached.originalUrl,
+        requestOptions: cached.requestOptions,
+        fromCache: true,
+        cacheAge: Date.now() - cached.timestamp
+      };
     }
     
     this.stats.requestCacheMisses++;
@@ -446,16 +465,16 @@ class SmartCache {
       body: result.body,
       url: normalizedUrl,
       originalUrl: url,
-      requestOptions: { method: method, headers: options.headers || {} }
+      requestOptions: { method: method, headers: options.headers || EMPTY }
     });
     
     if (this._debug) {
       const bodySize = result.body ? result.body.length : 0;
       console.log(formatLogMessage('debug', 
-        `[SmartCache] Cached request: ${normalizedUrl.substring(0, 50)}... (${result.status || 'unknown'}, ${Math.round(bodySize / 1024)}KB)`
+        `${SMART_CACHE_TAG} Cached request: ${normalizedUrl.substring(0, 50)}... (${result.status || 'unknown'}, ${Math.round(bodySize / 1024)}KB)`
       ));
       if (normalizedUrl !== url) {
-        console.log(formatLogMessage('debug', `[SmartCache] URL normalized: ${url} -> ${normalizedUrl}`));
+        console.log(formatLogMessage('debug', `${SMART_CACHE_TAG} URL normalized: ${url} -> ${normalizedUrl}`));
       }
     }
   }
@@ -473,7 +492,7 @@ class SmartCache {
     
     if (this._debug) {
       console.log(formatLogMessage('debug', 
-        `[SmartCache] Cleared request cache: ${clearedCount} entries removed`
+        `${SMART_CACHE_TAG} Cleared request cache: ${clearedCount} entries removed`
       ));
     }
     
@@ -552,15 +571,31 @@ class SmartCache {
     
     this.stats.regexCompilations++;
     try {
-      const regex = new RegExp(pattern.replace(this._regexStripPattern, '$1'));
+      // Strip /.../ wrapper only when the pattern actually has it. String.replace
+      // allocates a result string even on no-match; the charCode check is free
+      // and skips the allocation for the common bare-pattern case. (47 == '/')
+      let source = pattern;
+      if (
+        pattern.length >= 2 &&
+        pattern.charCodeAt(0) === 47 &&
+        pattern.charCodeAt(pattern.length - 1) === 47
+      ) {
+        source = pattern.slice(1, -1);
+      }
+      const regex = new RegExp(source);
       this.regexCache.set(pattern, regex);
       return regex;
     } catch (err) {
       if (this._debug) {
-        console.log(formatLogMessage('debug', 
-          `[SmartCache] Failed to compile regex: ${pattern}`
+        console.log(formatLogMessage('debug',
+          `${SMART_CACHE_TAG} Failed to compile regex: ${pattern}`
         ));
       }
+      // Cache the failure so repeated lookups of the same bad pattern don't
+      // re-enter the try/throw/catch path (a JS throw is ~10x the cost of
+      // compiling the regex itself). The reader at line 561 uses `!== undefined`
+      // so a stored `null` correctly registers as a cache hit.
+      this.regexCache.set(pattern, null);
       return null;
     }
   }
@@ -581,7 +616,7 @@ class SmartCache {
       this.stats.patternHits++;
       if (this._debug) {
         console.log(formatLogMessage('debug', 
-          `[SmartCache] Pattern cache hit for ${url.substring(0, 50)}...`
+          `${SMART_CACHE_TAG} Pattern cache hit for ${url.substring(0, 50)}...`
         ));
       }
       return cached;
@@ -621,7 +656,7 @@ class SmartCache {
       this.stats.responseHits++;
       if (this._debug) {
         console.log(formatLogMessage('debug', 
-          `[SmartCache] Response cache hit for ${url.substring(0, 50)}...`
+          `${SMART_CACHE_TAG} Response cache hit for ${url.substring(0, 50)}...`
         ));
       }
       return cached;
@@ -675,7 +710,7 @@ class SmartCache {
       this.stats.netToolsHits++;
       if (this._debug) {
         console.log(formatLogMessage('debug', 
-          `[SmartCache] ${tool.toUpperCase()} cache hit for ${domain}`
+          `${SMART_CACHE_TAG} ${tool.toUpperCase()} cache hit for ${domain}`
         ));
       }
       return cached;
@@ -763,7 +798,7 @@ class SmartCache {
       this.stats.memoryWarnings++;
       if (this._debug) {
         console.log(formatLogMessage('debug', 
-          `[SmartCache] Memory info: ${heapUsedMB}MB/${maxHeapMB}MB (${usagePercent.toFixed(1)}%)`
+          `${SMART_CACHE_TAG} Memory info: ${heapUsedMB}MB/${maxHeapMB}MB (${usagePercent.toFixed(1)}%)`
         ));
       }
     }
@@ -780,13 +815,13 @@ class SmartCache {
     
     if (this._debug) {
       console.log(formatLogMessage('debug', 
-        `[SmartCache] Memory ${level}: ${heapUsedMB}MB/${maxHeapMB}MB, performing cleanup...`
+        `${SMART_CACHE_TAG} Memory ${level}: ${heapUsedMB}MB/${maxHeapMB}MB, performing cleanup...`
       ));
     }
     
     if (level === 'critical' || this._highConcurrency) {
       // Aggressive cleanup - clear volatile caches
-      this.responseCache.clear();
+      if (this.responseCache) this.responseCache.clear();
       this.patternCache.clear();
       this.similarityCache.clear();
 
@@ -798,12 +833,12 @@ class SmartCache {
         const currentSize = this.domainCache.size;
         this.domainCache.clear();
         if (this._debug) {
-          console.log(formatLogMessage('debug', `[SmartCache] Cleared ${currentSize} domain cache entries`));
+          console.log(formatLogMessage('debug', `${SMART_CACHE_TAG} Cleared ${currentSize} domain cache entries`));
         }
       }
     } else if (level === 'warning') {
       // Moderate cleanup - clear largest cache
-      this.responseCache.clear();
+      if (this.responseCache) this.responseCache.clear();
 
       // NEW: Clear request cache during warning cleanup if it's large
       if (this._enableRequest && this.requestCache.size > this.options.requestCacheMaxSize * 0.8) {
@@ -863,7 +898,7 @@ class SmartCache {
       netToolsHitRate: (netToolsHitRate * 100).toFixed(2) + '%',
       domainCacheSize: this.domainCache.size,
       patternCacheSize: this.patternCache.size,
-      responseCacheSize: this.responseCache.size,
+      responseCacheSize: this.responseCache ? this.responseCache.size : 0,
       netToolsCacheSize: this.netToolsCache.size,
       similarityCacheSize: this.similarityCache.size,
       regexCacheSize: this.regexCache.size,
@@ -873,12 +908,14 @@ class SmartCache {
       requestCacheMemoryMB: (this._enableRequest && this.requestCache) ?
         Math.round((this.requestCache.calculatedSize || 0) / 1048576) : 0,
       totalCacheEntries: this.domainCache.size + this.patternCache.size +
-        this.responseCache.size + this.netToolsCache.size +
+        (this.responseCache ? this.responseCache.size : 0) + this.netToolsCache.size +
         this.similarityCache.size + this.regexCache.size + ((this._enableRequest && this.requestCache) ? this.requestCache.size : 0),
       memoryUsageMB: Math.round(heapUsed / 1048576),
       memoryMaxMB: Math.round(maxHeap / 1048576),
       memoryUsagePercent: ((heapUsed / maxHeap) * 100).toFixed(1) + '%',
-      responseCacheMemoryMB: Math.round((this.responseCache.calculatedSize || 0) / 1048576)
+      responseCacheMemoryMB: this.responseCache
+        ? Math.round((this.responseCache.calculatedSize || 0) / 1048576)
+        : 0
     };
   }
   
@@ -888,7 +925,7 @@ class SmartCache {
   clear() {
     this.domainCache.clear();
     this.patternCache.clear();
-    this.responseCache.clear();
+    if (this.responseCache) this.responseCache.clear();
     this.netToolsCache.clear();
     this.similarityCache.clear();
     this.regexCache.clear();
@@ -898,7 +935,7 @@ class SmartCache {
     this._initializeStats();
     
     if (this._debug) {
-      console.log(formatLogMessage('debug', '[SmartCache] All caches cleared'));
+      console.log(formatLogMessage('debug', `${SMART_CACHE_TAG} All caches cleared`));
     }
   }
   
@@ -909,7 +946,7 @@ class SmartCache {
   _logMemorySkip(operation) {
     if (this._debug) {
       console.log(formatLogMessage('debug', 
-        `[SmartCache] Skipping ${operation} due to memory pressure`
+        `${SMART_CACHE_TAG} Skipping ${operation} due to memory pressure`
       ));
     }
   }  
@@ -936,28 +973,41 @@ class SmartCache {
       // Validate cache age
       if (data.timestamp && now - data.timestamp > 24 * 60 * 60 * 1000) {
         if (this._debug) {
-          console.log(formatLogMessage('debug', 
-            '[SmartCache] Persistent cache too old, ignoring'
+          console.log(formatLogMessage('debug',
+            `${SMART_CACHE_TAG} Persistent cache too old, ignoring`
           ));
         }
         return;
       }
       
-      // Load domain cache
+      // Load domain cache. Validate shape per-entry: a corrupted or
+      // version-mismatched on-disk file shouldn't be able to inject junk
+      // (missing timestamp, future timestamp, non-string keys, etc.).
       if (data.domainCache && Array.isArray(data.domainCache)) {
         const entries = data.domainCache;
+        const ttl = this.options.ttl;
         for (let i = 0; i < entries.length; i++) {
-          if (now - entries[i][1].timestamp < this.options.ttl) {
-            this.domainCache.set(entries[i][0], entries[i][1]);
-          }
+          const e = entries[i];
+          if (!Array.isArray(e) || e.length !== 2) continue;
+          const key = e[0];
+          const val = e[1];
+          if (typeof key !== 'string' || !val || typeof val !== 'object') continue;
+          const ts = val.timestamp;
+          if (typeof ts !== 'number' || ts > now || now - ts >= ttl) continue;
+          this.domainCache.set(key, val);
         }
       }
-      
-      // Load nettools cache
+
+      // Load nettools cache (same shape validation).
       if (data.netToolsCache && Array.isArray(data.netToolsCache)) {
         const entries = data.netToolsCache;
         for (let i = 0; i < entries.length; i++) {
-          this.netToolsCache.set(entries[i][0], entries[i][1]);
+          const e = entries[i];
+          if (!Array.isArray(e) || e.length !== 2) continue;
+          const key = e[0];
+          const val = e[1];
+          if (typeof key !== 'string' || val === undefined) continue;
+          this.netToolsCache.set(key, val);
         }
       }
       
@@ -965,13 +1015,13 @@ class SmartCache {
       
       if (this._debug) {
         console.log(formatLogMessage('debug', 
-          `[SmartCache] Loaded persistent cache: ${this.domainCache.size} domains, ${this.netToolsCache.size} nettools`
+          `${SMART_CACHE_TAG} Loaded persistent cache: ${this.domainCache.size} domains, ${this.netToolsCache.size} nettools`
         ));
       }
     } catch (err) {
       if (this._debug) {
         console.log(formatLogMessage('debug', 
-          `[SmartCache] Failed to load persistent cache: ${err.message}`
+          `${SMART_CACHE_TAG} Failed to load persistent cache: ${err.message}`
         ));
       }
     }
@@ -987,7 +1037,7 @@ class SmartCache {
     if (this.saveInProgress) {
       this.pendingSave = true;
       if (this._debug) {
-        console.log(formatLogMessage('debug', '[SmartCache] Save in progress, marking pending...'));
+        console.log(formatLogMessage('debug', `${SMART_CACHE_TAG} Save in progress, marking pending...`));
       }
       return;
     }
@@ -1032,7 +1082,7 @@ class SmartCache {
         if (writeErr) {
           if (this._debug) {
             console.log(formatLogMessage('debug', 
-              `[SmartCache] Failed to write cache temp file: ${writeErr.message}`
+              `${SMART_CACHE_TAG} Failed to write cache temp file: ${writeErr.message}`
             ));
           }
           this.saveInProgress = false;
@@ -1043,14 +1093,14 @@ class SmartCache {
           if (renameErr) {
             if (this._debug) {
               console.log(formatLogMessage('debug', 
-                `[SmartCache] Failed to rename cache file: ${renameErr.message}`
+                `${SMART_CACHE_TAG} Failed to rename cache file: ${renameErr.message}`
               ));
             }
           } else {
             this.stats.persistenceSaves++;
             if (this._debug) {
               console.log(formatLogMessage('debug', 
-                `[SmartCache] Saved cache to disk: ${cacheFile}`
+                `${SMART_CACHE_TAG} Saved cache to disk: ${cacheFile}`
               ));
             }
           }
@@ -1069,7 +1119,7 @@ class SmartCache {
     } catch (err) {
       if (this._debug) {
         console.log(formatLogMessage('debug', 
-          `[SmartCache] Failed to save cache: ${err.message}`
+          `${SMART_CACHE_TAG} Failed to save cache: ${err.message}`
         ));
       }
       this.saveInProgress = false;
@@ -1131,7 +1181,7 @@ class SmartCache {
     const errors = [];
     
     if (!silent) {
-      console.log(`\n???  Clearing cache...`);
+      console.log(`\n${messageColors.cleanup('Clearing cache...')}`);
     }
     
     // Try the directory first -- rmSync recursive handles all files inside
@@ -1200,13 +1250,13 @@ class SmartCache {
     
     if (!silent) {
       if (clearedItems > 0) {
-        console.log(`? Cache cleared: ${clearedItems} item(s), ${result.sizeMB}MB freed`);
+        console.log(messageColors.cleanup(`Cache cleared: ${clearedItems} item(s), ${result.sizeMB}MB freed`));
       } else {
-        console.log(`??  No cache files found to clear`);
+        console.log(messageColors.cleanup(`No cache files found to clear`));
       }
-      
+
       if (errors.length > 0) {
-        console.warn(`??  ${errors.length} error(s) occurred during cache clearing`);
+        console.warn(messageColors.warn(`${errors.length} error(s) occurred during cache clearing`));
       }
     }
     

package/lib/socks-relay.js

@@ -19,7 +19,8 @@
 
 const net = require('net');
 const { SocksClient } = require('socks');
-const { formatLogMessage } = require('./colorize');
+const { formatLogMessage, messageColors } = require('./colorize');
+const SOCKS_RELAY_TAG = messageColors.processing('[socks-relay]');
 
 // upstreamKey -> { server, port, activeSockets:Set<net.Socket> }
 const _relays = new Map();
@@ -63,7 +64,7 @@ function handleClient(client, upstream, forceDebug) {
   handshakeTimer = setTimeout(() => {
     if (phase !== 'piping') {
       if (forceDebug) {
-        console.log(formatLogMessage('proxy', `[socks-relay] handshake timeout (phase=${phase}) — closing`));
+        console.log(formatLogMessage('proxy', `${SOCKS_RELAY_TAG} handshake timeout (phase=${phase}) — closing`));
       }
       cleanup();
     }
@@ -152,7 +153,7 @@ function handleClient(client, upstream, forceDebug) {
           });
         } catch (e) {
           if (forceDebug) {
-            console.log(formatLogMessage('proxy', `[socks-relay] upstream connect failed (${host}:${port}): ${e.message}`));
+            console.log(formatLogMessage('proxy', `${SOCKS_RELAY_TAG} upstream connect failed (${host}:${port}): ${e.message}`));
           }
           failReply(client, 0x05);             // connection refused
           return cleanup();
@@ -178,7 +179,7 @@ function handleClient(client, upstream, forceDebug) {
       }
     } catch (e) {
       if (forceDebug) {
-        console.log(formatLogMessage('proxy', `[socks-relay] handler error: ${e.message}`));
+        console.log(formatLogMessage('proxy', `${SOCKS_RELAY_TAG} handler error: ${e.message}`));
       }
       cleanup();
     }
@@ -224,7 +225,7 @@ async function ensureRelay(upstream, forceDebug = false) {
       server.removeListener('error', onErr);
       // Keep a listener so a late server error doesn't crash the process.
       server.on('error', (e) => {
-        if (forceDebug) console.log(formatLogMessage('proxy', `[socks-relay] server error: ${e.message}`));
+        if (forceDebug) console.log(formatLogMessage('proxy', `${SOCKS_RELAY_TAG} server error: ${e.message}`));
       });
       resolve();
     });
@@ -233,7 +234,7 @@ async function ensureRelay(upstream, forceDebug = false) {
   const port = server.address().port;
   _relays.set(key, { server, port, activeSockets });
   if (forceDebug) {
-    console.log(formatLogMessage('proxy', `[socks-relay] 127.0.0.1:${port} -> ${upstream.host}:${upstream.port} (auth user "${upstream.username}")`));
+    console.log(formatLogMessage('proxy', `${SOCKS_RELAY_TAG} 127.0.0.1:${port} -> ${upstream.host}:${upstream.port} (auth user "${upstream.username}")`));
   }
   return port;
 }
@@ -258,7 +259,7 @@ async function closeAllRelays(forceDebug = false) {
     await new Promise((res) => {
       try { r.server.close(() => res()); } catch (_) { res(); }
     });
-    if (forceDebug) console.log(formatLogMessage('proxy', `[socks-relay] closed relay for ${key}`));
+    if (forceDebug) console.log(formatLogMessage('proxy', `${SOCKS_RELAY_TAG} closed relay for ${key}`));
   }
   _relays.clear();
 }