clean-up: execution-manager simplified

Author: shadowfax92

src/lib/execution/ExecutionManager.ts

@@ -2,22 +2,12 @@ import { Execution, ExecutionOptions } from './Execution'
 import { PubSub } from '@/lib/pubsub'
 import { Logging } from '@/lib/utils/Logging'
 
-// Default execution ID for backwards compatibility
-const DEFAULT_EXECUTION_ID = 'default'
-
-// Maximum concurrent executions allowed
-const MAX_CONCURRENT_EXECUTIONS = 10
-
-// Execution cleanup timeout (30 minutes)
-const EXECUTION_CLEANUP_TIMEOUT = 30 * 60 * 1000
-
 /**
  * Manages all active execution instances.
  * Handles creation, retrieval, and lifecycle management.
  */
 export class ExecutionManager {
   private executions: Map<string, Execution> = new Map()
-  private cleanupTimers: Map<string, NodeJS.Timeout> = new Map()
   private static instance: ExecutionManager | null = null
 
   constructor() {
@@ -47,16 +37,6 @@ export class ExecutionManager {
       throw new Error(`Execution ${executionId} already exists`)
     }
 
-    // Check maximum concurrent executions
-    if (this.executions.size >= MAX_CONCURRENT_EXECUTIONS) {
-      // Try to clean up completed executions first
-      this._cleanupCompletedExecutions()
-      
-      if (this.executions.size >= MAX_CONCURRENT_EXECUTIONS) {
-        throw new Error(`Maximum concurrent executions (${MAX_CONCURRENT_EXECUTIONS}) reached`)
-      }
-    }
-
     // Get or create PubSub channel for this execution
     const pubsub = PubSub.getChannel(executionId)
 
@@ -69,9 +49,6 @@ export class ExecutionManager {
     const execution = new Execution(fullOptions, pubsub)
     this.executions.set(executionId, execution)
 
-    // Clear any existing cleanup timer
-    this._clearCleanupTimer(executionId)
-
     Logging.log('ExecutionManager', `Created execution ${executionId} (total: ${this.executions.size})`)
 
     return execution
@@ -89,23 +66,16 @@ export class ExecutionManager {
   /**
    * Delete an execution instance
    * @param executionId - Execution identifier to delete
-   * @param immediate - If true, dispose immediately without cleanup timer
    */
-  async delete(executionId: string, immediate: boolean = false): Promise<void> {
+  async delete(executionId: string): Promise<void> {
     const execution = this.executions.get(executionId)
 
     if (!execution) {
       Logging.log('ExecutionManager', `Execution ${executionId} not found for deletion`)
       return
     }
 
-    if (immediate) {
-      // Immediate disposal
-      await this._disposeExecution(executionId)
-    } else {
-      // Schedule cleanup after timeout (allows for reconnection)
-      this._scheduleCleanup(executionId)
-    }
+    await this._disposeExecution(executionId)
   }
 
   /**
@@ -181,12 +151,6 @@ export class ExecutionManager {
    * Dispose all executions and cleanup
    */
   async disposeAll(): Promise<void> {
-    // Cancel all cleanup timers
-    for (const timer of this.cleanupTimers.values()) {
-      clearTimeout(timer)
-    }
-    this.cleanupTimers.clear()
-
     // Dispose all executions
     const disposalPromises = []
     for (const executionId of this.executions.keys()) {
@@ -219,66 +183,8 @@ export class ExecutionManager {
     // Delete PubSub channel
     PubSub.deleteChannel(executionId)
 
-    // Clear cleanup timer
-    this._clearCleanupTimer(executionId)
-
     Logging.log('ExecutionManager', `Disposed execution ${executionId} (remaining: ${this.executions.size})`)
   }
 
-  /**
-   * Schedule cleanup of an execution after timeout
-   * @private
-   */
-  private _scheduleCleanup(executionId: string): void {
-    // Clear any existing timer
-    this._clearCleanupTimer(executionId)
-
-    // Schedule new cleanup
-    const timer = setTimeout(async () => {
-      Logging.log('ExecutionManager', `Auto-cleanup triggered for execution ${executionId}`)
-      await this._disposeExecution(executionId)
-    }, EXECUTION_CLEANUP_TIMEOUT)
-
-    this.cleanupTimers.set(executionId, timer)
-    
-    Logging.log('ExecutionManager', `Scheduled cleanup for execution ${executionId} in ${EXECUTION_CLEANUP_TIMEOUT}ms`)
-  }
 
-  /**
-   * Clear cleanup timer for an execution
-   * @private
-   */
-  private _clearCleanupTimer(executionId: string): void {
-    const timer = this.cleanupTimers.get(executionId)
-    if (timer) {
-      clearTimeout(timer)
-      this.cleanupTimers.delete(executionId)
-    }
-  }
-
-  /**
-   * Clean up completed executions to free resources
-   * @private
-   */
-  private _cleanupCompletedExecutions(): void {
-    const toCleanup: string[] = []
-
-    // For now, we can only clean up executions that are not running
-    // In the future we might track completion time
-    for (const [id, execution] of this.executions) {
-      if (!execution.isRunning()) {
-        toCleanup.push(id)
-      }
-    }
-
-    for (const id of toCleanup) {
-      this._disposeExecution(id).catch(error => {
-        Logging.log('ExecutionManager', `Error cleaning up execution ${id}: ${error}`, 'error')
-      })
-    }
-
-    if (toCleanup.length > 0) {
-      Logging.log('ExecutionManager', `Cleaned up ${toCleanup.length} completed executions`)
-    }
-  }
 }