scripts-orchestrator 2.0.0 → 2.1.0

package/README.md

@@ -39,13 +39,14 @@ Create a configuration file (default: `scripts-orchestrator.config.js`) that def
 
 ```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
+  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
+  kill_command: 'kill_storybook',   // Optional kill command to kill the process
+  health_check: {                   // Health check configuration
     url: 'http://localhost:port',
     max_attempts: 20,
     interval: 2000

package/lib/orchestrator.js

@@ -52,6 +52,7 @@ export class Orchestrator {
       should_retry,
       process_tracking = false,
       health_check,
+      kill_command,
     } = commandConfig;
 
     const startTime = Date.now();
@@ -87,6 +88,7 @@ export class Orchestrator {
           url: checkUrl,
           startedByScript: false,
           process_tracking,
+          kill_command,
         });
         this.commandTimings.set(command, Date.now() - startTime);
         visited.delete(command);
@@ -144,12 +146,14 @@ export class Orchestrator {
         await new Promise((resolve) => setTimeout(resolve, 1000));
       }
 
-      const { success, output } = await this.processManager.runCommand(
-        attempt === 1 ? command : retry_command || command,
+      const { success, output } = await this.processManager.runCommand({
+        cmd: attempt === 1 ? command : retry_command || command,
         logFile,
         background,
-        health_check,
-      );
+        healthCheck: health_check,
+        kill_command,
+        isRetry: attempt > 1,
+      });
       commandOutput = output;
       result = success;
 

package/lib/process-manager.js

@@ -11,17 +11,18 @@ export class ProcessManager {
     this.backgroundProcessesDetails = [];
   }
 
-  addBackgroundProcess({ command, url, startedByScript, process_tracking }) {
+  addBackgroundProcess({ command, url, startedByScript, process_tracking, kill_command }) {
     this.logger.verbose(`Adding background process: ${command} (${url})`);
     this.backgroundProcessesDetails.push({
       command,
       url,
       startedByScript,
       process_tracking,
+      kill_command,
     });
   }
 
-  async runCommand(cmd, logFile, background = false, healthCheck = null) {
+  async runCommand({ cmd, logFile, background = false, healthCheck = null, kill_command = null, isRetry = false }) {
     const LOGS_DIR = path.resolve(process.cwd(), 'scripts-orchestrator-logs');
     const LOG_FILE = logFile || path.join(LOGS_DIR, `${cmd}.log`);
 
@@ -31,8 +32,12 @@ export class ProcessManager {
         fs.mkdirSync(LOGS_DIR, { recursive: true });
       }
 
-      this.logger.verbose(`Clearing log file at ${LOG_FILE}`);
-      fs.writeFileSync(LOG_FILE, ''); // Clear the log file
+      if (!isRetry) {
+        this.logger.verbose(`Clearing log file at ${LOG_FILE}`);
+        fs.writeFileSync(LOG_FILE, ''); // Clear the log file
+      } else {
+        this.logger.verbose(`Appending to existing log file at ${LOG_FILE} (retry attempt)`);
+      }
     } catch (error) {
       this.logger.error(`Failed to setup log file: ${error.message}`);
       return Promise.resolve({ success: false, output: '' });
@@ -42,7 +47,7 @@ export class ProcessManager {
       this.logger.info(`Running: npm run ${cmd}`);
       
       // Create isolated environment for each process
-      const isolatedEnv = this.createIsolatedEnvironment(cmd);
+      const isolatedEnv = this.createIsolatedEnvironment({ command: cmd });
       
       const options = {
         shell: true,
@@ -103,6 +108,7 @@ export class ProcessManager {
                   startTime: Date.now(),
                   url: healthCheck?.url,
                   startedByScript: true,
+                  kill_command,
                 });
                 
                 this.logger.verbose(`Unreferencing process ${processGroupId}`);
@@ -172,7 +178,7 @@ export class ProcessManager {
     });
   }
 
-  createIsolatedEnvironment(command) {
+  createIsolatedEnvironment({ command }) {
     // Create a deep copy to avoid any reference sharing
     const baseEnv = JSON.parse(JSON.stringify(process.env));
     
@@ -201,8 +207,17 @@ export class ProcessManager {
 
   async cleanup() {
     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 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 }) => {
+      async ({ command, pgid, url, startedByScript, kill_command }) => {
         if (!startedByScript) {
           this.logger.verbose(
             `- Skipping cleanup for ${command} (${url}) as it was not started by this script`,
@@ -210,6 +225,26 @@ export class ProcessManager {
           return;
         }
 
+        this.logger.verbose(`- Processing cleanup for ${command} (kill_command: ${kill_command})`);
+
+        // Try custom kill command first if specified
+        if (kill_command) {
+          try {
+            this.logger.verbose(`- Using custom kill command: npm run ${kill_command}`);
+            const result = await this.runCommand({ cmd: kill_command, logFile: null, background: false });
+            if (result.success) {
+              this.logger.verbose(`- Successfully killed ${command} using custom command`);
+              return;
+            } else {
+              this.logger.verbose('- Custom kill command failed, falling back to process signals');
+            }
+          } catch (error) {
+            this.logger.verbose(`- Custom kill command error: ${error.message}, falling back`);
+          }
+        } else {
+          this.logger.verbose(`- No kill_command specified for ${command}, using process signals`);
+        }
+
         try {
           // First try to kill the process group
           try {

package/package.json

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

package/scripts-orchestrator.config.js

@@ -1,83 +1,115 @@
-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;
+export default {
+  phases: [
+    {
+      name: 'build',
+      parallel: [
+        {
+          command: 'build',
+          description: 'Build the project',
+          status: 'enabled',
+          attempts: 1,
+        },
+        {
+          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',
+        },
+      ],
+    },
+    {
+      name: 'storybook tests',
+      parallel: [
+        {
+          command: 'test-storybook',
+          description: 'Run Storybook tests',
+          status: 'enabled',
+          attempts: 2,
+          dependencies: [
+            {
+              command: 'storybook_silent',
+              background: true,
+              wait: 5000,
+              kill_command: 'kill_storybook',
+              dependencies: [],
+              // Add process tracking
+              process_tracking: true,
+              // Add health check
+              health_check: {
+                url: 'http://localhost:6006',
+                max_attempts: 20,
+                interval: 2000,
+              },
+            },
+          ],
+        },
+      ],
+    },
+    {
+      name: 'unit tests',
+      parallel: [
+        {
+          command: 'test-ci',
+          description: 'Run unit tests',
+          status: 'enabled',
+          attempts: 2,
+          should_retry: (output) => {
+            // Check for test failures in both formats
+            const testSuiteFailureMatch = output.match(
+              /Test Suites:.*?\(\d+\) failed/,
+            );
+            const individualTestFailureMatch =
+              output.match(/✘\s*(\d+)\s*failing/);
+
+            const hasTestSuiteFailures =
+              testSuiteFailureMatch && parseInt(testSuiteFailureMatch[1]) > 0;
+            const hasIndividualTestFailures =
+              individualTestFailureMatch &&
+              parseInt(individualTestFailureMatch[1]) > 0;
+
+            const hasTestFailures =
+              hasTestSuiteFailures || hasIndividualTestFailures;
 
-      // Check for coverage failures
-      const coverageSummaryMatch = output.match(
-        /Jest: "global" coverage threshold/,
-      );
-      const hasCoverageFailures = coverageSummaryMatch !== null;
+            // Check for "Test suite failed to run" in logs
+            if (output.includes('Test suite failed to run')) {
+              console.error('Certain tests could not be run');
+              return false; // Don't retry if certain tests could not be run
+            }
 
-      if (!hasTestFailures && hasCoverageFailures) {
-        console.log(
-          'Tests have passed but coverage thresholds have not been met',
-        );
-        return false; // Don't retry if only coverage failed
-      }
+            if (!hasTestFailures) {
+              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
+            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,
+    {
+      name: 'playwright',
+      parallel: [
+        {
+          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',
+            },
+          ],
         },
-      },
-    ],
-  },
-  {
-    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',
-      },
-    ],
-  },
-];
+      ],
+    },
+  ],
+};