19.6.1

ts/proxies/http-proxy/function-cache.ts

@@ -30,6 +30,9 @@ export class FunctionCache {
   // Logger
   private logger: ILogger;
   
+  // Cleanup interval timer
+  private cleanupInterval: NodeJS.Timeout | null = null;
+  
   /**
    * Creates a new function cache
    * 
@@ -48,7 +51,12 @@ export class FunctionCache {
     this.defaultTtl = options.defaultTtl || 5000; // 5 seconds default
     
     // Start the cache cleanup timer
-    setInterval(() => this.cleanupCache(), 30000); // Cleanup every 30 seconds
+    this.cleanupInterval = setInterval(() => this.cleanupCache(), 30000); // Cleanup every 30 seconds
+    
+    // Make sure the interval doesn't keep the process alive
+    if (this.cleanupInterval.unref) {
+      this.cleanupInterval.unref();
+    }
   }
   
   /**
@@ -256,4 +264,16 @@ export class FunctionCache {
     this.portCache.clear();
     this.logger.info('Function cache cleared');
   }
+  
+  /**
+   * Destroy the cache and cleanup resources
+   */
+  public destroy(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.clearCache();
+    this.logger.debug('Function cache destroyed');
+  }
 }

ts/proxies/http-proxy/http-proxy.ts

@@ -464,6 +464,11 @@ export class HttpProxy implements IMetricsTracker {
     // Stop WebSocket handler
     this.webSocketHandler.shutdown();
     
+    // Destroy request handler (cleans up intervals and caches)
+    if (this.requestHandler && typeof this.requestHandler.destroy === 'function') {
+      this.requestHandler.destroy();
+    }
+    
     // Close all tracked sockets
     const socketCleanupPromises = this.socketMap.getArray().map(socket => 
       cleanupSocket(socket, 'http-proxy-stop', { immediate: true })

ts/proxies/http-proxy/request-handler.ts

@@ -42,6 +42,9 @@ export class RequestHandler {
 
   // Security manager for IP filtering, rate limiting, etc.
   public securityManager: SecurityManager;
+  
+  // Rate limit cleanup interval
+  private rateLimitCleanupInterval: NodeJS.Timeout | null = null;
 
   constructor(
     private options: IHttpProxyOptions,
@@ -54,9 +57,14 @@ export class RequestHandler {
     this.securityManager = new SecurityManager(this.logger);
 
     // Schedule rate limit cleanup every minute
-    setInterval(() => {
+    this.rateLimitCleanupInterval = setInterval(() => {
       this.securityManager.cleanupExpiredRateLimits();
     }, 60000);
+    
+    // Make sure the interval doesn't keep the process alive
+    if (this.rateLimitCleanupInterval.unref) {
+      this.rateLimitCleanupInterval.unref();
+    }
   }
 
   /**
@@ -741,4 +749,27 @@ export class RequestHandler {
     stream.end('Not Found: No route configuration for this request');
     if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
   }
+  
+  /**
+   * Cleanup resources and stop intervals
+   */
+  public destroy(): void {
+    if (this.rateLimitCleanupInterval) {
+      clearInterval(this.rateLimitCleanupInterval);
+      this.rateLimitCleanupInterval = null;
+    }
+    
+    // Close all HTTP/2 sessions
+    for (const [key, session] of this.h2Sessions) {
+      session.close();
+    }
+    this.h2Sessions.clear();
+    
+    // Clear function cache if it has a destroy method
+    if (this.functionCache && typeof this.functionCache.destroy === 'function') {
+      this.functionCache.destroy();
+    }
+    
+    this.logger.debug('RequestHandler destroyed');
+  }
 }