scripts-orchestrator 2.4.2 → 2.6.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,32 @@ 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;
+let logFolder = 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 === '--logFolder' && i + 1 < args.length) {
+    logFolder = 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>] [--logFolder <log-directory>]');
   process.exit(1);
 }
 
@@ -25,8 +44,18 @@ 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;
+}
+
+// Check for log_folder in config if not provided via command line
+if (!logFolder && commandsConfig.log_folder) {
+  logFolder = commandsConfig.log_folder;
+}
+
 // Create and run the orchestrator
-const orchestrator = new Orchestrator(commandsConfig);
+const orchestrator = new Orchestrator(commandsConfig, startPhase, logFolder);
 
 // Enhanced signal handlers
 const handleSignal = async (signal) => {

package/lib/logger.js

@@ -8,6 +8,14 @@ const argv = yargs(hideBin(process.argv))
     type: 'boolean',
     description: 'Run with verbose logging',
   })
+  .option('phase', {
+    type: 'string',
+    description: 'Start execution from a specific phase',
+  })
+  .option('logFolder', {
+    type: 'string',
+    description: 'Specify the directory for log files',
+  })
   .parse();
 
 class Logger {

package/lib/orchestrator.js

@@ -3,8 +3,10 @@ import { healthCheck } from './health-check.js';
 import { log } from './logger.js';
 
 export class Orchestrator {
-  constructor(config) {
+  constructor(config, startPhase = null, logFolder = null) {
     this.config = config;
+    this.startPhase = startPhase;
+    this.logFolder = logFolder;
     this.processManager = processManager;
     this.healthCheck = healthCheck;
     this.logger = log;
@@ -12,6 +14,11 @@ export class Orchestrator {
     this.skippedCommands = [];
     this.commandTimings = new Map();
     
+    // Set the log folder in process manager
+    if (logFolder) {
+      this.processManager.setLogFolder(logFolder);
+    }
+    
     // Flatten commands for easier tracking
     this.allCommands = this.flattenCommands(config);
   }
@@ -226,6 +233,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 +246,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 +289,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 || 

package/lib/process-manager.js

@@ -10,6 +10,12 @@ export class ProcessManager {
     this.logger = log;
     this.backgroundProcesses = [];
     this.backgroundProcessesDetails = [];
+    this.logFolder = 'scripts-orchestrator-logs'; // Default log folder
+  }
+
+  setLogFolder(logFolder) {
+    this.logFolder = logFolder;
+    this.logger.verbose(`Log folder set to: ${logFolder}`);
   }
 
   addBackgroundProcess({ command, url, startedByScript, process_tracking, kill_command }) {
@@ -24,7 +30,8 @@ export class ProcessManager {
   }
 
   async runCommand({ cmd, logFile, background = false, healthCheck = null, kill_command = null, isRetry = false }) {
-    const LOGS_DIR = path.resolve(process.cwd(), 'scripts-orchestrator-logs');
+    const baseDir = this.logFolder ? path.resolve(this.logFolder) : process.cwd();
+    const LOGS_DIR = path.join(baseDir, 'scripts-orchestrator-logs');
     const LOG_FILE = logFile || path.join(LOGS_DIR, `${cmd}.log`);
 
     try {

package/package.json

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