scripts-orchestrator 2.4.0 → 2.4.2

package/lib/orchestrator.js

@@ -225,6 +225,7 @@ export class Orchestrator {
   async run() {
     try {
       let hasFailures = false;
+      let phaseFailed = false;
 
       // Handle both old array format and new phases format
       if (Array.isArray(this.config)) {
@@ -237,6 +238,15 @@ export class Orchestrator {
       } else if (this.config.phases) {
         // New: Run phases sequentially, commands within phases in parallel
         for (const phase of this.config.phases) {
+          if (phaseFailed) {
+            // Mark all commands in remaining phases as skipped
+            phase.parallel.forEach(({ command }) => {
+              this.skippedCommands.push(command);
+              this.commandTimings.set(command, 0);
+            });
+            continue;
+          }
+
           this.logger.info(`\n🔄 Starting phase: ${phase.name}`);
           
           const tasks = phase.parallel.map((commandConfig) =>
@@ -248,8 +258,8 @@ export class Orchestrator {
           
           if (phaseHasFailures) {
             hasFailures = true;
+            phaseFailed = true;
             this.logger.error(`❌ Phase "${phase.name}" completed with failures`);
-            break; // Stop executing remaining phases on failure
           } else {
             this.logger.success(`✅ Phase "${phase.name}" completed successfully`);
           }
@@ -266,16 +276,32 @@ export class Orchestrator {
 
       this.summarizeResults();
       
-      // Exit with appropriate status
+      // Cleanup before exit since finally blocks don't run after process.exit()
+      try {
+        await this.processManager.cleanup();
+      } catch (error) {
+        this.logger.error(`Cleanup failed: ${error.message}`);
+      }
+      
+      // Force exit with appropriate status
       if (hasFailures) {
+        this.logger.info('Exiting with failure status...');
         process.exit(1);
+      } else {
+        this.logger.info('Exiting with success status...');
+        process.exit(0);
       }
-    } finally {
+    } catch (error) {
+      this.logger.error(`Orchestrator failed: ${error.message}`);
+      
+      // Cleanup on error
       try {
         await this.processManager.cleanup();
-      } catch (error) {
-        this.logger.error(`Cleanup failed: ${error.message}`);
+      } catch (cleanupError) {
+        this.logger.error(`Cleanup failed: ${cleanupError.message}`);
       }
+      
+      process.exit(1);
     }
   }
 } 

package/lib/process-manager.js

@@ -246,25 +246,29 @@ export class ProcessManager {
   }
 
   async cleanup() {
-    this.logger.info('\nCleaning up background processes...');
+    try {
+      this.logger.info('\nCleaning up background processes...');
     
-    // Debug: Log the number of processes we're tracking
-    this.logger.info(`- Found ${this.backgroundProcessesDetails.length} background processes to clean up`);
+      // Debug: Log the number of processes we're tracking
+      this.logger.info(`- Found ${this.backgroundProcessesDetails.length} background processes to clean up`);
     
-    // Debug: Log each process details
-    this.backgroundProcessesDetails.forEach(({ command, pgid, url, startedByScript, kill_command }, index) => {
-      this.logger.verbose(`- Process ${index + 1}: command=${command}, pgid=${pgid}, url=${url}, startedByScript=${startedByScript}, kill_command=${kill_command}`);
-    });
+      // Debug: Log each process details
+      this.backgroundProcessesDetails.forEach(({ command, pgid, url, startedByScript, kill_command }, index) => {
+        this.logger.verbose(`- Process ${index + 1}: command=${command}, pgid=${pgid}, url=${url}, startedByScript=${startedByScript}, kill_command=${kill_command}`);
+      });
     
-    const killPromises = this.backgroundProcessesDetails.map(
-      async ({ command, pgid, url, startedByScript, kill_command }) => {
-        await this.cleanupProcess({ command, pgid, url, startedByScript, kill_command });
-      },
-    );
+      const killPromises = this.backgroundProcessesDetails.map(
+        async ({ command, pgid, url, startedByScript, kill_command }) => {
+          await this.cleanupProcess({ command, pgid, url, startedByScript, kill_command });
+        },
+      );
 
-    await Promise.all(killPromises);
-    this.backgroundProcesses = [];
-    this.backgroundProcessesDetails = [];
+      await Promise.allSettled(killPromises);
+      this.backgroundProcesses = [];
+      this.backgroundProcessesDetails = [];
+    } catch (error) {
+      this.logger.error(`Cleanup failed: ${error.message}`);
+    }
   }
 
   async cleanupCommand(commandName) {
@@ -288,7 +292,7 @@ export class ProcessManager {
       }
     );
 
-    await Promise.all(killPromises);
+    await Promise.allSettled(killPromises);
     
     // Remove the cleaned up processes from our tracking arrays
     this.backgroundProcesses = this.backgroundProcesses.filter(pgid => 
@@ -359,17 +363,19 @@ export class ProcessManager {
       process.kill(pgid, 'SIGTERM');
 
       await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          clearInterval(checkInterval);
+        let timeout, checkInterval;
+        
+        timeout = setTimeout(() => {
+          if (checkInterval) clearInterval(checkInterval);
           reject(new Error('Process termination timeout'));
         }, 5000);
 
-        const checkInterval = setInterval(() => {
+        checkInterval = setInterval(() => {
           try {
             process.kill(pgid, 0);
           } catch (error) {
-            clearInterval(checkInterval);
-            clearTimeout(timeout);
+            if (checkInterval) clearInterval(checkInterval);
+            if (timeout) clearTimeout(timeout);
             resolve();
           }
         }, 100);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scripts-orchestrator",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "A powerful script orchestrator for running parallel commands with dependency management, background processes, and health checks",
   "main": "lib/index.js",
   "type": "module",