scripts-orchestrator 1.0.0

package/README.md

@@ -0,0 +1,131 @@
+# Scripts Orchestrator
+
+A powerful script orchestrator for running parallel commands with dependency management, background processes, and health checks. Perfect for CI/CD pipelines and automated testing workflows.
+
+## Installation
+
+```bash
+# Install as a development dependency
+npm install --save-dev scripts-orchestrator
+
+# Or install globally
+npm install -g scripts-orchestrator
+```
+
+## Features
+
+- **Parallel Execution**: Runs multiple commands concurrently for faster execution
+- **Dependency Management**: Handles command dependencies and ensures proper execution order
+- **Background Processes**: Supports running commands in the background with health checks
+- **Retry Mechanism**: Configurable retry attempts for failed commands
+- **Process Management**: Proper cleanup of background processes
+- **Health Checks**: Verifies service availability before proceeding
+- **Comprehensive Logging**: Detailed logging of command execution and results
+
+## Configuration
+
+Create a configuration file (default: `scripts-orchestrator.config.js`) that defines an array of commands to execute. Each command can have the following properties:
+
+```javascript
+{
+  command: 'command_name',        // The npm script to run
+  description: 'Description',     // Optional description
+  status: 'enabled',             // 'enabled' or 'disabled'
+  attempts: 1,                   // Number of retry attempts
+  dependencies: [],              // Array of dependent commands
+  background: false,             // Whether to run in background
+  health_check: {                // Health check configuration
+    url: 'http://localhost:port',
+    max_attempts: 20,
+    interval: 2000
+  },
+  should_retry: (output) => {    // Custom retry logic
+    // Return true to retry, false to skip
+  }
+}
+```
+
+## Command Types
+
+The orchestrator is completely agnostic to what commands it runs. It can execute any npm scripts or shell commands. Common use cases include:
+
+1. **Build Processes**: Compile, bundle, or build your project
+2. **Testing**: Run unit tests, integration tests, or end-to-end tests
+3. **Code Quality**: Run linters, formatters, or static analysis tools
+4. **Documentation**: Generate documentation or run documentation tests
+5. **Deployment**: Run deployment scripts or environment checks
+6. **Custom Scripts**: Execute any custom npm scripts or shell commands
+
+The orchestrator doesn't care what the commands do - it just ensures they run in the correct order, handles dependencies, manages background processes, and provides proper logging and error handling.
+
+## Usage
+
+### Local Installation
+
+1. Create a configuration file (e.g., `scripts-orchestrator.config.js`) in your project root
+2. Configure your commands in the config file
+3. Add a script to your package.json:
+   ```json
+   {
+     "scripts": {
+       "scripts-orchestrator": "npx scripts-orchestrator"
+     }
+   }
+   ```
+4. Run the orchestrator:
+   ```bash
+   # Using default config file (scripts-orchestrator.config.js)
+   npm run scripts-orchestrator
+
+   # Or specify a custom config file
+   npm run scripts-orchestrator -- ./path/to/your/config.js
+   ```
+
+### Global Installation
+
+1. Create a configuration file in your project root
+2. Configure your commands in the config file
+3. Run the orchestrator:
+   ```bash
+   # Using default config file (scripts-orchestrator.config.js)
+   scripts-orchestrator
+
+   # Or specify a custom config file
+   scripts-orchestrator ./path/to/your/config.js
+   ```
+
+## Error Handling
+
+- The script tracks failed and skipped commands
+- Provides detailed error messages and logs
+- Handles process cleanup on script termination
+- Manages background processes and ensures proper cleanup
+
+## Logging
+
+- Each command's output is logged to `logs/scripts-orchestrator_<command>.log`
+- Provides real-time status updates during execution
+- Summarizes results at the end of execution
+
+## Exit Codes
+
+- `0`: All commands executed successfully
+- `1`: One or more commands failed or were skipped
+
+## Signal Handling
+
+The script properly handles various termination signals:
+- SIGINT (Ctrl+C)
+- SIGTERM
+- SIGQUIT
+- SIGHUP
+- Uncaught exceptions
+- Unhandled rejections
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT © Vivek Kodira 

package/index.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+/**
+ * @file index.js
+ * @description CLI entry point for the scripts-orchestrator package
+ */
+
+import path from 'path';
+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';
+
+// 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]');
+  process.exit(1);
+}
+
+// Import the config file
+const commandsConfig = (await import(path.resolve(process.cwd(), configPath))).default;
+
+// Create and run the orchestrator
+const orchestrator = new Orchestrator(commandsConfig);
+
+// Enhanced signal handlers
+const handleSignal = async (signal) => {
+  log.warn(`\nReceived ${signal} signal. Cleaning up...`);
+  try {
+    await orchestrator.processManager.cleanup();
+  } catch (error) {
+    log.error(`Cleanup failed: ${error.message}`);
+  }
+  process.exit(1);
+};
+
+// Attach handlers for various signals
+process.on('SIGINT', () => handleSignal('interrupt'));
+process.on('SIGTERM', () => handleSignal('termination'));
+process.on('SIGQUIT', () => handleSignal('quit'));
+process.on('SIGHUP', () => handleSignal('hangup'));
+
+// Handle uncaught exceptions and rejections
+process.on('uncaughtException', async (error) => {
+  log.error(`Uncaught Exception: ${error.message}`);
+  await handleSignal('exception');
+});
+
+process.on('unhandledRejection', async (reason, promise) => {
+  log.error(`Unhandled Rejection at: ${promise}, reason: ${reason}`);
+  await handleSignal('rejection');
+});
+
+// Run the orchestrator
+orchestrator.run();

package/lib/health-check.js

@@ -0,0 +1,44 @@
+import { spawn } from 'child_process';
+import { log } from './logger.js';
+
+export class HealthCheck {
+  constructor() {
+    this.logger = log;
+  }
+
+  async waitForUrl({url, maxAttempts = 20, interval = 2000, silent=false}) {
+    !silent && this.logger.info(`Waiting for ${url} to be available...`);
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const result = await new Promise((resolve) => {
+          const curl = spawn('curl', ['-s', '-o', '/dev/null', '-w', '%{http_code}', url]);
+          let output = '';
+          curl.stdout.on('data', (data) => {
+            output += data.toString();
+          });
+          curl.on('close', (code) => {
+            resolve({ code, output });
+          });
+        });
+
+        if (result.code === 0 && result.output === '200') {
+          !silent && this.logger.success(`${url} is available`);
+          return true;
+        }
+      } catch (error) {
+        !silent && this.logger.verbose(`Attempt ${attempt}/${maxAttempts} failed: ${error.message}`);
+      }
+
+      if (attempt < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, interval));
+      }
+    }
+    
+    !silent && this.logger.error(`Failed to connect to ${url} after ${maxAttempts} attempts`);
+    
+    return false;
+  }
+}
+
+// For backward compatibility
+export const healthCheck = new HealthCheck(); 

package/lib/index.js

@@ -0,0 +1,7 @@
+import { Orchestrator } from './orchestrator.js';
+import { ProcessManager } from './process-manager.js';
+import { HealthCheck } from './health-check.js';
+import { Logger } from './logger.js';
+
+export { Orchestrator, ProcessManager, HealthCheck, Logger };
+export default Orchestrator; 

package/lib/logger.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+const argv = yargs(hideBin(process.argv))
+  .option('verbose', {
+    alias: 'v',
+    type: 'boolean',
+    description: 'Run with verbose logging',
+  })
+  .parse();
+
+class Logger {
+  constructor() {
+    this.isVerbose = argv.verbose;
+  }
+
+  info(message) {
+    console.log(chalk.blue(`[INFO] ${message}`));
+  }
+
+  success(message) {
+    console.log(chalk.green(`[SUCCESS] ${message}`));
+  }
+
+  error(message) {
+    console.error(chalk.red(`[ERROR] ${message}`));
+  }
+
+  warn(message) {
+    console.warn(chalk.yellow(`[WARN] ${message}`));
+  }
+
+  verbose(message) {
+    if (this.isVerbose) {
+      console.log(chalk.gray(`[VERBOSE] ${message}`));
+    }
+  }
+}
+
+// Create a single instance
+const logger = new Logger();
+
+// Export both the class and the instance
+export { Logger, logger as log }; 

package/lib/orchestrator.js

@@ -0,0 +1,181 @@
+import { processManager } from './process-manager.js';
+import { healthCheck } from './health-check.js';
+import { log } from './logger.js';
+
+export class Orchestrator {
+  constructor(config) {
+    this.config = config;
+    this.processManager = processManager;
+    this.healthCheck = healthCheck;
+    this.logger = log;
+    this.failedCommands = [];
+    this.skippedCommands = [];
+  }
+
+  async executeCommand(commandConfig, visited = new Set()) {
+    const {
+      command,
+      dependencies = [],
+      background = false,
+      status = 'enabled',
+      logFile,
+      attempts = 1,
+      retry_command,
+      should_retry,
+      process_tracking = false,
+      health_check,
+    } = commandConfig;
+
+    // Check for circular dependencies
+    if (visited.has(command)) {
+      this.logger.error(
+        `Circular dependency detected: ${Array.from(visited).join(' -> ')} -> ${command}`,
+      );
+      this.failedCommands.push(command);
+      return false;
+    }
+    visited.add(command);
+
+    // Skip execution if the command is disabled
+    if (status === 'disabled') {
+      this.logger.warn(`Skipping: npm run ${command} (status: disabled)`);
+      this.skippedCommands.push(command);
+      visited.delete(command);
+      return true;
+    }
+
+    const checkUrl = health_check?.url;
+    if (checkUrl) {
+      this.logger.info(`Checking if ${checkUrl} is already available...`);
+      const urlAvailable = await this.healthCheck.waitForUrl({url: checkUrl, maxAttempts: 1, silent:true});
+      if (urlAvailable) {
+        this.logger.verbose(`${checkUrl} is already available. Skipping ${command} start.`);
+        this.processManager.addBackgroundProcess({
+          command,
+          url: checkUrl,
+          startedByScript: false,
+          process_tracking,
+        });
+        visited.delete(command);
+        return true;
+      }
+    }
+
+    // Execute dependencies first
+    for (const dependency of dependencies) {
+      const dependencySuccess = await this.executeCommand(dependency, visited);
+      if (!dependencySuccess) {
+        this.logger.error(`Skipping ${command} due to failed dependency`);
+        this.skippedCommands.push(command);
+        visited.delete(command);
+        return false;
+      }
+
+      if (dependency.health_check?.url) {
+        this.logger.info(`Waiting for ${dependency.health_check.url} to be available...`);
+        const urlAvailable = await this.healthCheck.waitForUrl({
+          url: dependency.health_check.url,
+          maxAttempts: dependency.health_check?.max_attempts || 20,
+          interval: dependency.health_check?.interval || 2000,
+        });
+        if (!urlAvailable) {
+          this.logger.error(
+            `URL ${dependency.health_check.url} is not available after maximum attempts`,
+          );
+          this.skippedCommands.push(command);
+          visited.delete(command);
+          return false;
+        }
+        if (dependency.wait) {
+          this.logger.verbose(`Waiting ${dependency.wait}ms`);
+          await new Promise((resolve) => {
+            setTimeout(() => {
+              this.logger.verbose(`Resolving after a wait of ${dependency.wait}ms`);
+              resolve(true);
+            }, dependency.wait);
+          });
+        }
+      }
+    }
+
+    // Execute the main command with retries
+    let result = false;
+    let commandOutput = '';
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      if (attempt > 1) {
+        this.logger.warn(`Retrying ${command} (attempt ${attempt}/${attempts})`);
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+
+      const { success, output } = await this.processManager.runCommand(
+        attempt === 1 ? command : retry_command || command,
+        logFile,
+        background,
+        health_check,
+      );
+      commandOutput = output;
+      result = success;
+
+      if (result) {
+        this.failedCommands = this.failedCommands.filter(cmd => cmd !== command);
+        break;
+      } else if (attempt < attempts) {
+        if (should_retry && !should_retry(commandOutput)) {
+          this.logger.warn(
+            `${command} failed but doesn't meet retry criteria. Skipping retry.`,
+          );
+          break;
+        }
+        this.logger.error(`Attempt ${attempt}/${attempts} failed for ${command}`);
+      }
+    }
+
+    visited.delete(command);
+    return result;
+  }
+
+  summarizeResults() {
+    this.logger.info('\nCommand Summary:');
+    this.config.forEach(({ command }) => {
+      if (this.failedCommands.includes(command)) {
+        this.logger.error(`- ${command}: ❌ (See logs/scripts-orchestrator_${command}.log)`);
+      } else if (this.skippedCommands.includes(command)) {
+        this.logger.warn(`- ${command}: ⚠️ (Skipped due to failed dependency)`);
+      } else {
+        this.logger.success(`- ${command}: ✅`);
+      }
+    });
+
+    if (this.failedCommands.length > 0 || this.skippedCommands.length > 0) {
+      this.logger.error('\n❌ Some commands failed or were skipped. See details above.');
+    } else {
+      this.logger.success('\n🎉 All commands executed successfully!');
+    }
+  }
+
+  async run() {
+    try {
+      // Run top-level commands in parallel
+      const tasks = this.config.map((commandConfig) =>
+        this.executeCommand(commandConfig),
+      );
+
+      // Wait for all top-level commands to complete
+      await Promise.all(tasks);
+
+      // Add a small delay to ensure all processes have finished
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      this.summarizeResults();
+    } 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

@@ -0,0 +1,295 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { log } from './logger.js';
+
+
+export class ProcessManager {
+  constructor() {
+    this.logger = log;
+    this.backgroundProcesses = [];
+    this.backgroundProcessesDetails = [];
+  }
+
+  addBackgroundProcess({ command, url, startedByScript, process_tracking }) {
+    this.logger.verbose(`Adding background process: ${command} (${url})`);
+    this.backgroundProcessesDetails.push({
+      command,
+      url,
+      startedByScript,
+      process_tracking,
+    });
+  }
+
+  async runCommand(cmd, logFile, background = false, healthCheck = null) {
+    const LOGS_DIR = path.resolve(process.cwd(), 'scripts-orchestrator-logs');
+    const LOG_FILE = logFile || path.join(LOGS_DIR, `${cmd}.log`);
+
+    try {
+      if (!fs.existsSync(LOGS_DIR)) {
+        this.logger.verbose(`Creating logs directory at ${LOGS_DIR}`);
+        fs.mkdirSync(LOGS_DIR, { recursive: true });
+      }
+
+      this.logger.verbose(`Clearing log file at ${LOG_FILE}`);
+      fs.writeFileSync(LOG_FILE, ''); // Clear the log file
+    } catch (error) {
+      this.logger.error(`Failed to setup log file: ${error.message}`);
+      return Promise.resolve({ success: false, output: '' });
+    }
+
+    return new Promise((resolve) => {
+      this.logger.info(`Running: npm run ${cmd}`);
+      const options = {
+        shell: true,
+        detached: background,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        cwd: process.cwd(),
+        env: {
+          ...process.env,
+          NODE_ENV: process.env.NODE_ENV || 'development',
+        },
+        windowsHide: true,
+        ...(background ? { processGroup: true } : {}),
+      };
+
+      //this.logger.verbose(`Process options: ${JSON.stringify(options, null, 2)}`);
+
+      try {
+        this.logger.verbose(`Spawning process with command: npm run ${cmd}`);
+        const processInstance = spawn('npm', ['run', cmd], options);
+
+        processInstance.on('error', (error) => {
+          this.logger.error(`Failed to start process: ${error.message}`);
+          //this.logger.verbose(`Process error details: ${JSON.stringify(error, null, 2)}`);
+          resolve({ success: false, output: '' });
+        });
+
+        if (background) {
+          const processGroupId = processInstance.pid;
+          this.logger.verbose(`Background process spawned with PID: ${processGroupId}`);
+
+          processInstance.stdout.on('data', (data) => {
+            try {
+              fs.appendFileSync(LOG_FILE, data.toString());
+            } catch (error) {
+              this.logger.error(`Failed to write to log file: ${error.message}`);
+            }
+          });
+
+          processInstance.stderr.on('data', (data) => {
+            try {
+              fs.appendFileSync(LOG_FILE, data.toString());
+            } catch (error) {
+              this.logger.error(`Failed to write to log file: ${error.message}`);
+            }
+          });
+
+          const verifyProcess = async () => {
+            const maxAttempts = 5;
+            const baseDelay = 1000;
+
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+              try {
+                this.logger.verbose(`Verifying process ${processGroupId} (attempt ${attempt}/${maxAttempts})`);
+                process.kill(processGroupId, 0);
+                this.logger.verbose(`Process ${processGroupId} is running`);
+                
+                this.backgroundProcesses.push(processGroupId);
+                this.backgroundProcessesDetails.push({
+                  command: cmd,
+                  pgid: processGroupId,
+                  startTime: Date.now(),
+                  url: healthCheck?.url,
+                  startedByScript: true,
+                });
+                
+                this.logger.verbose(`Unreferencing process ${processGroupId}`);
+                processInstance.unref();
+                
+                this.logger.verbose(
+                  `Background process started: npm run ${cmd} (PGID: ${processGroupId})`,
+                );
+                return { success: true, output: '' };
+              } catch (error) {
+                if (attempt === maxAttempts) {
+                  this.logger.error(`Failed to start background process: npm run ${cmd}`);
+                  this.logger.verbose(`Final verification attempt failed: ${error.message}`);
+                  return { success: false, output: '' };
+                }
+                this.logger.verbose(`Verification attempt ${attempt} failed: ${error.message}`);
+                this.logger.verbose(`Waiting ${baseDelay * Math.pow(2, attempt - 1)}ms before next attempt`);
+                await new Promise((resolve) =>
+                  setTimeout(resolve, baseDelay * Math.pow(2, attempt - 1)),
+                );
+              }
+            }
+            return { success: false, output: '' };
+          };
+
+          verifyProcess().then(resolve);
+        } else {
+          processInstance.stdout.on('data', (data) => {
+            try {
+              fs.appendFileSync(LOG_FILE, data.toString());
+            } catch (error) {
+              this.logger.error(`Failed to write to log file: ${error.message}`);
+            }
+          });
+
+          processInstance.stderr.on('data', (data) => {
+            try {
+              fs.appendFileSync(LOG_FILE, data.toString());
+            } catch (error) {
+              this.logger.error(`Failed to write to log file: ${error.message}`);
+            }
+          });
+
+          processInstance.on('close', async (code) => {
+            let output = '';
+            try {
+              output = fs.readFileSync(LOG_FILE, 'utf8');
+            } catch (error) {
+              this.logger.error(`Failed to read log file: ${error.message}`);
+            }
+
+            if (code !== 0) {
+              this.logger.error(`Failed: npm run ${cmd} (exit code: ${code})`);
+              this.logger.verbose(`Process output: ${output}`);
+              resolve({ success: false, output });
+            } else {
+              this.logger.success(`Completed: npm run ${cmd}`);
+              resolve({ success: true, output });
+            }
+          });
+        }
+      } catch (error) {
+        this.logger.error(`Failed to spawn process: ${error.message}`);
+        //this.logger.verbose(`Spawn error details: ${JSON.stringify(error, null, 2)}`);
+        resolve({ success: false, output: '' });
+      }
+    });
+  }
+
+  async cleanup() {
+    this.logger.info('\nCleaning up background processes...');
+    const killPromises = this.backgroundProcessesDetails.map(
+      async ({ command, pgid, url, startedByScript }) => {
+        if (!startedByScript) {
+          this.logger.verbose(
+            `- Skipping cleanup for ${command} (${url}) as it was not started by this script`,
+          );
+          return;
+        }
+
+        try {
+          // First try to kill the process group
+          try {
+            process.kill(pgid, 0);
+          } catch (error) {
+            this.logger.verbose(
+              `- Process ${command} (PGID: ${pgid}) already terminated`,
+            );
+            return;
+          }
+
+          // Try SIGTERM first
+          process.kill(pgid, 'SIGTERM');
+
+          await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+              clearInterval(checkInterval);
+              reject(new Error('Process termination timeout'));
+            }, 5000);
+
+            const checkInterval = setInterval(() => {
+              try {
+                process.kill(pgid, 0);
+              } catch (error) {
+                clearInterval(checkInterval);
+                clearTimeout(timeout);
+                resolve();
+              }
+            }, 100);
+          });
+          this.logger.verbose(
+            `- Terminated background process: ${command} (PGID: ${pgid})`,
+          );
+        } catch (error) {
+          this.logger.verbose(`- Failed to terminate process group: ${error.message}`);
+        }
+
+        // Check if the URL is still responding after termination attempt
+        if (url) {
+          try {
+            const urlObj = new URL(url);
+            const port = urlObj.port || (urlObj.protocol === 'https:' ? '443' : '80');
+            
+            const curl = spawn('curl', ['-s', '-o', '/dev/null', '-w', '%{http_code}', url]);
+            const result = await new Promise((resolve) => {
+              let output = '';
+              curl.stdout.on('data', (data) => {
+                output += data.toString();
+              });
+              curl.on('close', (code) => {
+                resolve({ code, output });
+              });
+            });
+
+            if (result.code === 0 && result.output === '200') {
+              this.logger.verbose(`- URL ${url} is still responding after termination, finding process on port ${port}`);
+              
+              // Find and kill process using the port
+              try {
+                const lsof = spawn('lsof', ['-i', `:${port}`, '-t']);
+                const result = await new Promise((resolve) => {
+                  let output = '';
+                  lsof.stdout.on('data', (data) => {
+                    output += data.toString();
+                  });
+                  lsof.on('close', (code) => {
+                    resolve({ code, output });
+                  });
+                });
+
+                if (result.code === 0 && result.output.trim()) {
+                  const pids = result.output.trim().split('\n');
+                  for (const pid of pids) {
+                    try {
+                      process.kill(parseInt(pid), 'SIGKILL');
+                      this.logger.verbose(`- Killed process (PID: ${pid}) using port ${port}`);
+                    } catch (killError) {
+                      if (killError.code !== 'ESRCH') {
+                        this.logger.error(`- Failed to kill process (PID: ${pid}): ${killError.message}`);
+                      }
+                    }
+                  }
+                }
+              } catch (lsofError) {
+                this.logger.error(`- Failed to find process using port ${port}: ${lsofError.message}`);
+              }
+            }
+          } catch (error) {
+            this.logger.verbose(`- URL check failed: ${error.message}`);
+          }
+        }
+
+        // Final attempt to kill the process group with SIGKILL
+        try {
+          process.kill(pgid, 'SIGKILL');
+        } catch (error) {
+          if (error.code !== 'ESRCH') {
+            this.logger.error(`- Failed to kill process group with SIGKILL: ${error.message}`);
+          }
+        }
+      },
+    );
+
+    await Promise.all(killPromises);
+    this.backgroundProcesses = [];
+    this.backgroundProcessesDetails = [];
+  }
+}
+
+// For backward compatibility
+export const processManager = new ProcessManager(); 

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "scripts-orchestrator",
+  "version": "1.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",
+  "bin": {
+    "scripts-orchestrator": "./index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node index.js",
+    "lint": "eslint .",
+    "prepare": "npm run lint"
+  },
+  "keywords": [
+    "orchestrator",
+    "script",
+    "parallel",
+    "process",
+    "health-check",
+    "dependency",
+    "background",
+    "automation",
+    "ci",
+    "testing"
+  ],
+  "author": "vivekkodira@gmail.com",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vivekkodira/scripts-orchestrator.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vivekkodira/scripts-orchestrator/issues"
+  },
+  "homepage": "https://github.com/vivekkodira/scripts-orchestrator#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2"
+  },
+  "devDependencies": {
+    "eslint": "^8.0.0"
+  },
+  "files": [
+    "lib/",
+    "index.js",
+    "scripts-orchestrator.config.js",
+    "README.md"
+  ]
+}

package/scripts-orchestrator.config.js

@@ -0,0 +1,83 @@
+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) => {
+      // Check for actual test failures in the summary
+      const testSummaryMatch = output.match(/Test Suites:.*?(\d+) failed/);
+      const hasTestFailures =
+        testSummaryMatch && parseInt(testSummaryMatch[1]) > 0;
+
+      // Check for coverage failures
+      const coverageSummaryMatch = output.match(
+        /Jest: "global" coverage threshold/,
+      );
+      const hasCoverageFailures = coverageSummaryMatch !== null;
+
+      if (!hasTestFailures && hasCoverageFailures) {
+        console.log(
+          'Tests have passed but coverage thresholds have not been met',
+        );
+        return false; // Don't retry if only coverage failed
+      }
+
+      return hasTestFailures; // Only retry if there are actual test failures
+    },
+  },
+  {
+    command: 'test-storybook',
+    description: 'Run Storybook tests',
+    status: 'enabled',
+    attempts: 2,
+    dependencies: [
+      {
+        command: 'storybook_silent',
+        background: true,
+        wait: 5000,
+        kill_script: 'kill_storybook',
+        dependencies: [],
+        // Add process tracking
+        process_tracking: true,
+        // Add health check
+        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',
+  },
+  {
+    command: 'playwright_ci',
+    description: 'Run Playwright tests',
+    status: 'enabled',
+    attempts: 1, //Playwright internally retries in CI mode
+    dependencies: [
+      {
+        command: 'dev',
+        background: true,
+        url: 'http://localhost:5173',
+        kill: 'application_end',
+      },
+    ],
+  },
+];