scripts-orchestrator 2.4.1 → 2.5.0

package/README.md

@@ -165,8 +165,41 @@ The orchestrator doesn't care what the commands do - it just ensures they run (i
 
    # Or specify a custom config file
    npm run scripts-orchestrator -- ./path/to/your/config.js
+
+   # Start from a specific phase
+   npm run scripts-orchestrator -- --phase "unit tests"
+
+   # Start from a specific phase with custom config
+   npm run scripts-orchestrator -- ./path/to/your/config.js --phase "playwright"
    ```
 
+### Starting from a Specific Phase
+
+You can start the orchestrator from a specific phase instead of running all phases from the beginning. This is useful for debugging or when you want to skip earlier phases that have already been completed.
+
+#### Method 1: Command Line Argument
+```bash
+# Start from the "unit tests" phase
+npm run scripts-orchestrator -- --phase "unit tests"
+```
+
+#### Method 2: Configuration File
+```javascript
+export default {
+  start_phase: "unit tests",  // Start from this phase
+  phases: [
+    // ... your phases
+  ]
+};
+```
+
+**Note**: Command line arguments take precedence over configuration file settings.
+
+When starting from a specific phase:
+- All phases before the specified phase are skipped
+- Commands in skipped phases are marked as "skipped" in the final summary
+- The orchestrator validates that the specified phase exists and shows available phases if not found
+
 ## Error Handling
 
 - The script tracks failed and skipped commands

package/index.js

@@ -10,13 +10,28 @@ import fs from 'fs';
 import { Orchestrator } from './lib/index.js';
 import { log } from './lib/logger.js';
 
-// Get config file path from command line arguments
-const configPath = process.argv[2] || './scripts-orchestrator.config.js';
+// Parse command line arguments
+const args = process.argv.slice(2);
+let configPath = './scripts-orchestrator.config.js';
+let startPhase = null;
+
+// Parse arguments
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  
+  if (arg === '--phase' && i + 1 < args.length) {
+    startPhase = args[i + 1];
+    i++; // Skip the next argument since we consumed it
+  } else if (!arg.startsWith('--') && !configPath) {
+    // First non-flag argument is the config path
+    configPath = arg;
+  }
+}
 
 // Validate config file exists
 if (!fs.existsSync(configPath)) {
   log.error(`Error: Config file not found at ${configPath}`);
-  log.error('Usage: scripts-orchestrator [path-to-config-file]');
+  log.error('Usage: scripts-orchestrator [path-to-config-file] [--phase <phase-name>]');
   process.exit(1);
 }
 
@@ -25,8 +40,13 @@ const configFilePath = path.resolve(process.cwd(), configPath);
 const fileUrl = new URL(`file://${configFilePath}`).href;
 const commandsConfig = (await import(fileUrl)).default;
 
+// Check for start_phase in config if not provided via command line
+if (!startPhase && commandsConfig.start_phase) {
+  startPhase = commandsConfig.start_phase;
+}
+
 // Create and run the orchestrator
-const orchestrator = new Orchestrator(commandsConfig);
+const orchestrator = new Orchestrator(commandsConfig, startPhase);
 
 // Enhanced signal handlers
 const handleSignal = async (signal) => {

package/lib/orchestrator.js

@@ -3,8 +3,9 @@ import { healthCheck } from './health-check.js';
 import { log } from './logger.js';
 
 export class Orchestrator {
-  constructor(config) {
+  constructor(config, startPhase = null) {
     this.config = config;
+    this.startPhase = startPhase;
     this.processManager = processManager;
     this.healthCheck = healthCheck;
     this.logger = log;
@@ -226,6 +227,7 @@ export class Orchestrator {
     try {
       let hasFailures = false;
       let phaseFailed = false;
+      let startPhaseFound = false;
 
       // Handle both old array format and new phases format
       if (Array.isArray(this.config)) {
@@ -238,6 +240,21 @@ export class Orchestrator {
       } else if (this.config.phases) {
         // New: Run phases sequentially, commands within phases in parallel
         for (const phase of this.config.phases) {
+          // Check if we should start from this phase
+          if (this.startPhase && !startPhaseFound) {
+            if (phase.name === this.startPhase) {
+              startPhaseFound = true;
+              this.logger.info(`\n🎯 Starting from phase: ${phase.name}`);
+            } else {
+              // Mark all commands in previous phases as skipped
+              phase.parallel.forEach(({ command }) => {
+                this.skippedCommands.push(command);
+                this.commandTimings.set(command, 0);
+              });
+              continue;
+            }
+          }
+
           if (phaseFailed) {
             // Mark all commands in remaining phases as skipped
             phase.parallel.forEach(({ command }) => {
@@ -266,6 +283,13 @@ export class Orchestrator {
         }
       }
 
+      // Validate start phase if specified
+      if (this.startPhase && !startPhaseFound) {
+        const availablePhases = this.config.phases.map(p => p.name).join(', ');
+        this.logger.error(`❌ Start phase "${this.startPhase}" not found. Available phases: ${availablePhases}`);
+        process.exit(1);
+      }
+
       // Check final status
       hasFailures = hasFailures || 
                    this.failedCommands.length > 0 || 
@@ -276,16 +300,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.1",
+  "version": "2.5.0",
   "description": "A powerful script orchestrator for running parallel commands with dependency management, background processes, and health checks",
   "main": "lib/index.js",
   "type": "module",