@mxf-dev/core 2.0.5 → 3.0.0

package/src/services/PatternLearningService.ts

@@ -25,7 +25,7 @@
  * pattern learning and cross-agent pattern sharing capabilities.
  */
 
-import { Observable, Subject } from 'rxjs';
+import { Observable, Subject, Subscription } from 'rxjs';
 import { Logger } from '../utils/Logger.js';
 import { EventBus } from '../events/EventBus.js';
 import { Events } from '../events/EventNames.js';
@@ -69,8 +69,11 @@ export class PatternLearningService {
     private readonly patternCache = new Map<string, EnhancedParameterPattern[]>();
     private readonly cacheExpiry = new Map<string, number>();
     private readonly CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-    
-    private static instance: PatternLearningService;
+    private validationEventSubscription?: Subscription;
+    private patternCleanupInterval?: ReturnType<typeof setInterval>;
+    private cacheCleanupInterval?: ReturnType<typeof setInterval>;
+
+    private static instance: PatternLearningService | undefined;
 
     private constructor() {
         this.logger = new Logger('info', 'PatternLearningService', 'server');
@@ -985,7 +988,7 @@ export class PatternLearningService {
 
     private setupEventListeners(): void {
         // Listen to validation events from ValidationPerformanceService
-        this.validationService.validationEvents.subscribe(event => {
+        this.validationEventSubscription = this.validationService.validationEvents.subscribe(event => {
             // Convert validation events to pattern learning events when appropriate
             if (event.eventType === 'validation_success' && event.details.parameters) {
                 this.storeSuccessfulPattern(
@@ -1013,16 +1016,17 @@ export class PatternLearningService {
 
     private startPeriodicTasks(): void {
         // Pattern cleanup task - runs every hour
-        setInterval(async () => {
+        this.patternCleanupInterval = setInterval(async () => {
             try {
                 await this.cleanupStalePatterns();
             } catch (error) {
                 this.logger.error('Pattern cleanup task failed:', error);
             }
         }, 60 * 60 * 1000);
+        this.patternCleanupInterval.unref?.();
 
         // Cache cleanup task - runs every 10 minutes
-        setInterval(() => {
+        this.cacheCleanupInterval = setInterval(() => {
             const now = Date.now();
             for (const [key, expiry] of this.cacheExpiry.entries()) {
                 if (now > expiry) {
@@ -1030,6 +1034,7 @@ export class PatternLearningService {
                 }
             }
         }, 10 * 60 * 1000);
+        this.cacheCleanupInterval.unref?.();
     }
 
     private async cleanupStalePatterns(): Promise<void> {
@@ -1081,4 +1086,24 @@ export class PatternLearningService {
     public getConfig(): PatternLearningConfig {
         return { ...this.config };
     }
-}
+
+    /** Release every timer and subscription owned by this singleton. */
+    public shutdown(): void {
+        if (this.patternCleanupInterval) {
+            clearInterval(this.patternCleanupInterval);
+            this.patternCleanupInterval = undefined;
+        }
+        if (this.cacheCleanupInterval) {
+            clearInterval(this.cacheCleanupInterval);
+            this.cacheCleanupInterval = undefined;
+        }
+        this.validationEventSubscription?.unsubscribe();
+        this.validationEventSubscription = undefined;
+        this.clearAllCaches();
+        this.patternLearningEvents$.complete();
+
+        if (PatternLearningService.instance === this) {
+            PatternLearningService.instance = undefined;
+        }
+    }
+}

package/src/services/PerformanceOptimizationService.ts

@@ -32,6 +32,7 @@
 import { createBaseEventPayload } from '../schemas/EventPayloadSchema.js';
 import * as os from 'os';
 import { EventEmitter } from 'events';
+import type { Subscription } from 'rxjs';
 import { Logger } from '../utils/Logger.js';
 import { EventBus } from '../events/EventBus.js';
 import { Events } from '../events/EventNames.js';
@@ -195,8 +196,9 @@ export class PerformanceOptimizationService extends EventEmitter {
         optimizationsApplied: 0,
         performanceImprovement: 0
     };
-    
-    private static instance: PerformanceOptimizationService;
+    private readonly eventSubscriptions: Subscription[] = [];
+
+    private static instance: PerformanceOptimizationService | undefined;
     
     private constructor() {
         super();
@@ -880,8 +882,9 @@ proactiveValidationService.updateConfig({
         }
         
         this.autoTuningInterval = setInterval(() => {
-            this.performAutoTuning();
+            void this.performAutoTuning();
         }, this.autoTuningConfig.tuningInterval);
+        this.autoTuningInterval.unref?.();
         
     }
     
@@ -1002,6 +1005,7 @@ proactiveValidationService.updateConfig({
             // Emit resource update
             this.emit('resource_update', usage);
         }, 5000); // Every 5 seconds
+        this.resourceMonitorInterval.unref?.();
     }
     
     /**
@@ -1071,13 +1075,13 @@ proactiveValidationService.updateConfig({
      */
     private setupEventListeners(): void {
         // Listen to validation events for performance tracking
-        EventBus.server.on(Events.Mcp.TOOL_VALIDATION_STARTED, (event) => {
+        this.eventSubscriptions.push(EventBus.server.on(Events.Mcp.TOOL_VALIDATION_STARTED, (_event) => {
             // Track validation start times
-        });
+        }));
         
-        EventBus.server.on(Events.Mcp.TOOL_VALIDATION_COMPLETED, (event) => {
+        this.eventSubscriptions.push(EventBus.server.on(Events.Mcp.TOOL_VALIDATION_COMPLETED, (_event) => {
             // Track validation completion times
-        });
+        }));
     }
     
     // =============================================================================
@@ -1121,12 +1125,25 @@ proactiveValidationService.updateConfig({
     /**
      * Cleanup
      */
-    public cleanup(): void {
+    public shutdown(): void {
         if (this.resourceMonitorInterval) {
             clearInterval(this.resourceMonitorInterval);
+            this.resourceMonitorInterval = undefined;
         }
         if (this.autoTuningInterval) {
             clearInterval(this.autoTuningInterval);
+            this.autoTuningInterval = undefined;
+        }
+        for (const subscription of this.eventSubscriptions) {
+            subscription.unsubscribe();
+        }
+        this.eventSubscriptions.length = 0;
+        this.activeProfiles.clear();
+        this.clearMetrics();
+        this.removeAllListeners();
+
+        if (PerformanceOptimizationService.instance === this) {
+            PerformanceOptimizationService.instance = undefined;
         }
     }
-}
+}

package/src/services/PredictiveAnalyticsService.ts

@@ -32,6 +32,7 @@
 import { createBaseEventPayload } from '../schemas/EventPayloadSchema.js';
 import * as os from 'os';
 import { EventEmitter } from 'events';
+import type { Subscription } from 'rxjs';
 import { Logger } from '../utils/Logger.js';
 import { EventBus } from '../events/EventBus.js';
 import { Events } from '../events/EventNames.js';
@@ -291,9 +292,10 @@ export class PredictiveAnalyticsService extends EventEmitter {
         predictionAccuracy: 0
     };
     
-    private retrainInterval?: NodeJS.Timeout;
-    
-    private static instance: PredictiveAnalyticsService;
+    private retrainInterval?: ReturnType<typeof setInterval>;
+    private readonly eventSubscriptions: Subscription[] = [];
+
+    private static instance: PredictiveAnalyticsService | undefined;
     
     private constructor() {
         super();
@@ -307,9 +309,8 @@ export class PredictiveAnalyticsService extends EventEmitter {
         this.startRetrainSchedule();
 
         // TF.js model initialization is deferred to initializeTensorFlowModels().
-        // This service is instantiated at module load time (via validationAnalyticsController),
-        // which runs BEFORE MxfMLService.initialize() in server Step 2.8.
-        // The server calls initializeTensorFlowModels() after MxfMLService is ready.
+        // The server owns this service explicitly and calls initializeTensorFlowModels()
+        // only after MxfMLService is ready.
     }
     
     /**
@@ -2239,7 +2240,7 @@ export class PredictiveAnalyticsService extends EventEmitter {
      */
     private setupEventListeners(): void {
         // Collect training data from events
-        EventBus.server.on(Events.Mcp.TOOL_RESULT, async (event) => {
+        this.eventSubscriptions.push(EventBus.server.on(Events.Mcp.TOOL_RESULT, async (event) => {
             try {
                 const features = await this.extractFeatures(
                     event.agentId,
@@ -2265,7 +2266,7 @@ export class PredictiveAnalyticsService extends EventEmitter {
             } catch (error) {
                 this.logger.warn('Failed to collect training data:', error);
             }
-        });
+        }));
     }
     
     /**
@@ -2289,8 +2290,9 @@ export class PredictiveAnalyticsService extends EventEmitter {
             return;
         }
         this.retrainInterval = setInterval(() => {
-            this.trainModels();
+            void this.trainModels();
         }, this.config.retrainInterval);
+        this.retrainInterval.unref?.();
     }
     
     // =============================================================================
@@ -2342,8 +2344,19 @@ export class PredictiveAnalyticsService extends EventEmitter {
     public cleanup(): void {
         if (this.retrainInterval) {
             clearInterval(this.retrainInterval);
+            this.retrainInterval = undefined;
+        }
+        for (const subscription of this.eventSubscriptions) {
+            subscription?.unsubscribe();
+        }
+        this.eventSubscriptions.length = 0;
+        this.clearTrainingData();
+        this.modelMetadata.clear();
+        this.removeAllListeners();
+        if (PredictiveAnalyticsService.instance === this) {
+            PredictiveAnalyticsService.instance = undefined;
         }
         this.tfErrorPredictionReady = false;
         this.tfAnomalyAutoencoderReady = false;
     }
-}
+}

package/src/services/ProactiveValidationService.ts

@@ -25,7 +25,7 @@
  * Provides proactive validation to prevent errors before tool execution.
  */
 
-import { Observable, Subject } from 'rxjs';
+import { Observable, Subject, Subscription } from 'rxjs';
 import { Logger } from '../utils/Logger.js';
 import { EventBus } from '../events/EventBus.js';
 import { Events } from '../events/EventNames.js';
@@ -206,8 +206,12 @@ export class ProactiveValidationService {
         warningsGenerated: 0,
         suggestionsProvided: 0
     };
-    
-    private static instance: ProactiveValidationService;
+    private readonly eventSubscriptions: Subscription[] = [];
+    private metricsInterval?: ReturnType<typeof setInterval>;
+    private riskProfileInterval?: ReturnType<typeof setInterval>;
+    private cacheCleanupInterval?: ReturnType<typeof setInterval>;
+
+    private static instance: ProactiveValidationService | undefined;
 
     private constructor() {
         this.logger = new Logger('info', 'ProactiveValidationService', 'server');
@@ -882,30 +886,23 @@ export class ProactiveValidationService {
     }
 
     private async performBackgroundValidation(context: ValidationContext): Promise<void> {
-        // Perform validation without blocking
-        setTimeout(async () => {
-            try {
-                const result = await this.performBlockingValidation(context);
-                
-                // Store results for future reference
-                if (!result.valid) {
-                    this.logger.warn(`Background validation found issues for ${context.toolName}:`, result.errors);
-                    
-                    // Could emit events or store for analytics
-                    this.emitValidationEvent({
-                        timestamp: Date.now(),
-                        agentId: context.agentId,
-                        channelId: context.channelId,
-                        toolName: context.toolName,
-                        eventType: 'VALIDATION_COMPLETE',
-                        validationId: `bg_${context.requestId}`,
-                        details: { backgroundValidation: true, result }
-                    });
-                }
-            } catch (error) {
-                this.logger.warn(`Background validation failed for ${context.toolName}:`, error);
-            }
-        }, 0);
+        const result = await this.performBlockingValidation(context);
+
+        // Store results for future reference
+        if (!result.valid) {
+            this.logger.warn(`Background validation found issues for ${context.toolName}:`, result.errors);
+
+            // Could emit events or store for analytics
+            this.emitValidationEvent({
+                timestamp: Date.now(),
+                agentId: context.agentId,
+                channelId: context.channelId,
+                toolName: context.toolName,
+                eventType: 'VALIDATION_COMPLETE',
+                validationId: `bg_${context.requestId}`,
+                details: { backgroundValidation: true, result }
+            });
+        }
     }
 
     private async previewValidationErrors(
@@ -1193,39 +1190,41 @@ export class ProactiveValidationService {
     }
 
     private setupEventListeners(): void {
-        // Listen to tool execution events for learning
-        EventBus.server.on(Events.Mcp.TOOL_ERROR, (payload) => {
-            // Learn from validation failures
+        // Listen to tool execution events for learning. Each handler returns its
+        // promise so the EventBus shutdown drain waits for in-flight learning.
+        this.eventSubscriptions.push(EventBus.server.on(Events.Mcp.TOOL_ERROR, (payload): Promise<void> =>
             this.learnFromValidationFailure(payload).catch(error => {
                 this.logger.warn('Failed to learn from validation failure:', error);
-            });
-        });
+            })
+        ));
 
-        EventBus.server.on(Events.Mcp.TOOL_RESULT, (payload) => {
-            // Learn from successful validations
+        this.eventSubscriptions.push(EventBus.server.on(Events.Mcp.TOOL_RESULT, (payload): Promise<void> =>
             this.learnFromValidationSuccess(payload).catch(error => {
                 this.logger.warn('Failed to learn from validation success:', error);
-            });
-        });
+            })
+        ));
     }
 
     private startPeriodicTasks(): void {
         // Performance metrics reporting
-        setInterval(() => {
+        this.metricsInterval = setInterval(() => {
             this.reportPerformanceMetrics();
         }, 60 * 1000); // Every minute
+        this.metricsInterval.unref?.();
 
         // Risk profile updates
-        setInterval(() => {
+        this.riskProfileInterval = setInterval(() => {
             this.updateRiskProfiles().catch(error => {
                 this.logger.warn('Failed to update risk profiles:', error);
             });
         }, 10 * 60 * 1000); // Every 10 minutes
+        this.riskProfileInterval.unref?.();
 
         // Cache cleanup
-        setInterval(() => {
+        this.cacheCleanupInterval = setInterval(() => {
             this.cleanupExpiredCaches();
         }, 5 * 60 * 1000); // Every 5 minutes
+        this.cacheCleanupInterval.unref?.();
     }
 
     private async learnFromValidationFailure(payload: any): Promise<void> {
@@ -1382,4 +1381,31 @@ export class ProactiveValidationService {
         this.toolRiskProfiles.clear();
         this.toolRiskCacheExpiry.clear();
     }
-}
+
+    /** Release every timer and subscription owned by this singleton. */
+    public shutdown(): void {
+        if (this.metricsInterval) {
+            clearInterval(this.metricsInterval);
+            this.metricsInterval = undefined;
+        }
+        if (this.riskProfileInterval) {
+            clearInterval(this.riskProfileInterval);
+            this.riskProfileInterval = undefined;
+        }
+        if (this.cacheCleanupInterval) {
+            clearInterval(this.cacheCleanupInterval);
+            this.cacheCleanupInterval = undefined;
+        }
+        for (const subscription of this.eventSubscriptions) {
+            subscription.unsubscribe();
+        }
+        this.eventSubscriptions.length = 0;
+        this.activeValidations.clear();
+        this.clearCaches();
+        this.validationEvents$.complete();
+
+        if (ProactiveValidationService.instance === this) {
+            ProactiveValidationService.instance = undefined;
+        }
+    }
+}