scripts-orchestrator 1.2.2 → 2.0.0

package/README.md

@@ -88,112 +88,48 @@ export default [
 ];
 ```
 
-### Storybook Testing with Background Process
+### Basic Build and Test Pipeline with Phases
 ```javascript
-export default [
-  {
-    command: 'test-storybook',
-    description: 'Run Storybook tests',
-    status: 'enabled',
-    attempts: 2,
-    dependencies: [
-      {
-        command: 'storybook_silent',
-        background: true,
-        wait: 5000,
-        health_check: {
-          url: 'http://localhost:6006',
-          max_attempts: 20,
-          interval: 2000
+export default {
+  phases: [
+    {
+      name: 'build',
+      parallel: [
+        {
+          command: 'build',
+          description: 'Build the project',
+          status: 'enabled',
+          attempts: 1
         }
-      }
-    ]
-  }
-];
-```
-
-### Playwright Testing with Development Server
-```javascript
-export default [
-  {
-    command: 'playwright_ci',
-    description: 'Run Playwright tests',
-    status: 'enabled',
-    attempts: 1,
-    dependencies: [
-      {
-        command: 'dev',
-        background: true,
-        health_check: {
-          url: 'http://localhost:5173',
-          max_attempts: 20,
-          interval: 2000
+      ]
+    },
+    {
+      name: 'test',
+      parallel: [
+        {
+          command: 'test',
+          description: 'Run unit tests',
+          status: 'enabled',
+          attempts: 2,
+          should_retry: (output) => {
+            // Only retry if there are actual test failures
+            const testSummaryMatch = output.match(/Test Suites:.*?(\d+) failed/);
+            return testSummaryMatch && parseInt(testSummaryMatch[1]) > 0;
+          }
+        },
+        {
+          command: 'lint',
+          description: 'Run lint checks',
+          status: 'enabled'
         }
-      }
-    ]
-  }
-];
-```
-
-### Full CI Pipeline with Multiple Checks
-```javascript
-export default [
-  {
-    command: 'build',
-    description: 'Build the project',
-    status: 'enabled',
-    attempts: 1
-  },
-  {
-    command: 'test-ci',
-    description: 'Run unit tests',
-    status: 'enabled',
-    attempts: 2,
-    should_retry: (output) => {
-      const testSummaryMatch = output.match(/Test Suites:.*?(\d+) failed/);
-      const hasTestFailures = testSummaryMatch && parseInt(testSummaryMatch[1]) > 0;
-      const hasCoverageFailures = output.match(/Jest: "global" coverage threshold/);
-      
-      // Only retry for actual test failures, not coverage issues
-      return hasTestFailures;
+      ]
     }
-  },
-  {
-    command: 'test-storybook',
-    description: 'Run Storybook tests',
-    status: 'enabled',
-    attempts: 2,
-    dependencies: [
-      {
-        command: 'storybook_silent',
-        background: true,
-        wait: 5000,
-        health_check: {
-          url: 'http://localhost:6006',
-          max_attempts: 20,
-          interval: 2000
-        }
-      }
-    ]
-  },
-  {
-    command: 'stylelint',
-    description: 'Run stylelint checks',
-    status: 'enabled'
-  },
-  {
-    command: 'lint',
-    description: 'Run lint checks',
-    status: 'enabled'
-  },
-  {
-    command: 'jscpd',
-    description: 'Run code duplication checks',
-    status: 'enabled'
-  }
-];
+  ]
+};
 ```
 
+See more examples [here](./docs/samples.md)
+
 ## Command Types
 
 The orchestrator is completely agnostic to what commands it runs. It can execute any npm scripts. Common use cases include:
@@ -248,6 +184,17 @@ The orchestrator doesn't care what the commands do - it just ensures they run (i
 - `0`: All commands executed successfully
 - `1`: One or more commands failed or were skipped
 
+
+## History
+See [versions](./docs/versions.md)
+
+## Roadmap
+- Better UX to indicate what is happening
+- Tests to avoid regression
+- Retry should append to the log file
+- Run any shell command rather than assume the command is specified in package.json (? tentative)
+
+
 ## Disclaimer
 
 This software is provided "as is", without warranty of any kind, express or implied. The author(s) shall not be liable for any claims, damages, or other liabilities arising from the use of this software. Users are responsible for testing and verifying the software in their own environment before using it in production.
@@ -258,3 +205,5 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 ## License
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+

package/lib/orchestrator.js

@@ -11,6 +11,22 @@ export class Orchestrator {
     this.failedCommands = [];
     this.skippedCommands = [];
     this.commandTimings = new Map();
+    
+    // Flatten commands for easier tracking
+    this.allCommands = this.flattenCommands(config);
+  }
+
+  flattenCommands(config) {
+    // Handle both old array format and new phases format
+    if (Array.isArray(config)) {
+      return config;
+    }
+    
+    if (config.phases) {
+      return config.phases.flatMap(phase => phase.parallel || []);
+    }
+    
+    return [];
   }
 
   formatDuration(ms) {
@@ -120,6 +136,8 @@ export class Orchestrator {
     // Execute the main command with retries
     let result = false;
     let commandOutput = '';
+    let commandFailed = false;
+    
     for (let attempt = 1; attempt <= attempts; attempt++) {
       if (attempt > 1) {
         this.logger.warn(`Retrying ${command} (attempt ${attempt}/${attempts})`);
@@ -136,22 +154,29 @@ export class Orchestrator {
       result = success;
 
       if (result) {
+        // Remove from failed commands if it was there
         this.failedCommands = this.failedCommands.filter(cmd => cmd !== command);
+        commandFailed = false;
         break;
       } else if (attempt < attempts) {
         if (should_retry && !should_retry(commandOutput)) {
           this.logger.warn(
             `${command} failed but doesn't meet retry criteria. Skipping retry.`,
           );
-          this.failedCommands.push(command);
+          commandFailed = true;
           break;
         }
         this.logger.error(`Attempt ${attempt}/${attempts} failed for ${command}`);
+        commandFailed = true;
       } else {
-        this.failedCommands.push(command);
+        commandFailed = true;
       }
     }
 
+    if (commandFailed) {
+      this.failedCommands.push(command);
+    }
+
     this.commandTimings.set(command, Date.now() - startTime);
     visited.delete(command);
     return result;
@@ -159,20 +184,24 @@ export class Orchestrator {
 
   summarizeResults() {
     this.logger.info('\nCommand Summary:');
-    this.config.forEach(({ command }) => {
+    let hasFailures = false;
+    
+    this.allCommands.forEach(({ command }) => {
       const duration = this.commandTimings.get(command);
       const durationStr = duration ? ` (${this.formatDuration(duration)})` : '';
       
       if (this.failedCommands.includes(command)) {
+        hasFailures = true;
         this.logger.error(`- ${command}: ❌${durationStr} (See logs/scripts-orchestrator_${command}.log)`);
       } else if (this.skippedCommands.includes(command)) {
+        hasFailures = true;
         this.logger.warn(`- ${command}: ⚠️${durationStr} (Skipped due to failed dependency)`);
       } else {
         this.logger.success(`- ${command}: ✅${durationStr}`);
       }
     });
 
-    if (this.failedCommands.length > 0 || this.skippedCommands.length > 0) {
+    if (hasFailures) {
       this.logger.error('\n❌ Some commands failed or were skipped. See details above.');
     } else {
       this.logger.success('\n🎉 All commands executed successfully!');
@@ -181,27 +210,58 @@ export class Orchestrator {
 
   async run() {
     try {
-      // Run top-level commands in parallel
-      const tasks = this.config.map((commandConfig) =>
-        this.executeCommand(commandConfig),
-      );
+      let hasFailures = false;
 
-      // Wait for all top-level commands to complete
-      await Promise.all(tasks);
+      // Handle both old array format and new phases format
+      if (Array.isArray(this.config)) {
+        // Legacy: Run all commands in parallel
+        const tasks = this.config.map((commandConfig) =>
+          this.executeCommand(commandConfig),
+        );
+        const results = await Promise.all(tasks);
+        hasFailures = results.some(result => !result);
+      } else if (this.config.phases) {
+        // New: Run phases sequentially, commands within phases in parallel
+        for (const phase of this.config.phases) {
+          this.logger.info(`\n🔄 Starting phase: ${phase.name}`);
+          
+          const tasks = phase.parallel.map((commandConfig) =>
+            this.executeCommand(commandConfig),
+          );
+          
+          const results = await Promise.all(tasks);
+          const phaseHasFailures = results.some(result => !result);
+          
+          if (phaseHasFailures) {
+            hasFailures = 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`);
+          }
+        }
+      }
+
+      // Check final status
+      hasFailures = hasFailures || 
+                   this.failedCommands.length > 0 || 
+                   this.skippedCommands.length > 0;
 
       // Add a small delay to ensure all processes have finished
       await new Promise((resolve) => setTimeout(resolve, 1000));
 
       this.summarizeResults();
+      
+      // Exit with appropriate status
+      if (hasFailures) {
+        process.exit(1);
+      }
     } finally {
       try {
         await this.processManager.cleanup();
       } catch (error) {
         this.logger.error(`Cleanup failed: ${error.message}`);
       }
-      if (this.failedCommands.length > 0 || this.skippedCommands.length > 0) {
-        process.exit(1);
-      }
     }
   }
 } 

package/lib/process-manager.js

@@ -40,15 +40,16 @@ export class ProcessManager {
 
     return new Promise((resolve) => {
       this.logger.info(`Running: npm run ${cmd}`);
+      
+      // Create isolated environment for each process
+      const isolatedEnv = this.createIsolatedEnvironment(cmd);
+      
       const options = {
         shell: true,
         detached: background,
         stdio: ['ignore', 'pipe', 'pipe'],
         cwd: process.cwd(),
-        env: {
-          ...process.env,
-          NODE_ENV: process.env.NODE_ENV || 'development',
-        },
+        env: isolatedEnv,
         windowsHide: true,
         ...(background ? { processGroup: true } : {}),
       };
@@ -171,6 +172,33 @@ export class ProcessManager {
     });
   }
 
+  createIsolatedEnvironment(command) {
+    // Create a deep copy to avoid any reference sharing
+    const baseEnv = JSON.parse(JSON.stringify(process.env));
+    
+    // Set standard environment variables
+    const isolatedEnv = {
+      ...baseEnv,
+      NODE_ENV: process.env.NODE_ENV || 'development',
+      // Add command-specific environment isolation
+      SCRIPTS_ORCHESTRATOR_COMMAND: command,
+      SCRIPTS_ORCHESTRATOR_PID: process.pid.toString(),
+      // Force fresh PATH to avoid any dynamic modifications
+      PATH: process.env.PATH,
+      // Ensure npm/node paths are isolated
+      npm_config_cache: path.join(process.cwd(), 'node_modules/.cache/npm'),
+      // Prevent npm from sharing config between parallel processes
+      npm_config_progress: 'false',
+      npm_config_loglevel: 'error',
+    };
+
+    // Remove any potentially problematic environment variables
+    delete isolatedEnv.npm_lifecycle_event;
+    delete isolatedEnv.npm_lifecycle_script;
+    
+    return isolatedEnv;
+  }
+
   async cleanup() {
     this.logger.info('\nCleaning up background processes...');
     const killPromises = this.backgroundProcessesDetails.map(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scripts-orchestrator",
-  "version": "1.2.2",
+  "version": "2.0.0",
   "description": "A powerful script orchestrator for running parallel commands with dependency management, background processes, and health checks",
   "main": "lib/index.js",
   "type": "module",
@@ -8,7 +8,8 @@
     "scripts-orchestrator": "index.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test:coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --detectOpenHandles --runInBand",
     "start": "node index.js",
     "lint": "eslint .",
     "prepare": "npm run lint"
@@ -29,7 +30,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Pratishthan/scripts-orchestrator"
+    "url": "git+https://github.com/Pratishthan/scripts-orchestrator.git"
   },
   "bugs": {
     "url": "https://github.com/Pratishthan/scripts-orchestrator/issues"
@@ -39,10 +40,14 @@
     "node": ">=14.0.0"
   },
   "dependencies": {
-    "chalk": "^4.1.2"
+    "chalk": "^4.1.2",
+    "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "eslint": "^8.0.0"
+    "@types/jest": "^29.5.14",
+    "eslint": "^8.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.3.3"
   },
   "files": [
     "lib/",