scripts-orchestrator 2.1.0 → 2.4.0

package/README.md

@@ -192,7 +192,6 @@ 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)
 
 

package/lib/health-check.js

@@ -1,4 +1,3 @@
-import { spawn } from 'child_process';
 import { log } from './logger.js';
 
 export class HealthCheck {
@@ -6,22 +5,46 @@ export class HealthCheck {
     this.logger = log;
   }
 
+  /**
+   * Static method to make a simple HTTP/HTTPS request
+   * @param {string} url - The URL to check
+   * @param {number} timeout - Request timeout in milliseconds (default: 5000)
+   * @returns {Promise<{statusCode: number|null, success: boolean, error?: string}>}
+   */
+  static async makeHttpRequest(url, timeout = 5000) {
+    try {
+      // Use Node.js http/https module instead of curl for cross-platform compatibility
+      const urlObj = new URL(url);
+      const isHttps = urlObj.protocol === 'https:';
+      const httpModule = isHttps ? await import('https') : await import('http');
+      
+      return await new Promise((resolve) => {
+        const req = httpModule.default.get(url, (res) => {
+          resolve({ statusCode: res.statusCode, success: true });
+          res.destroy(); // Close the response stream
+        });
+        
+        req.on('error', (error) => {
+          resolve({ statusCode: null, success: false, error: error.message });
+        });
+        
+        req.setTimeout(timeout, () => {
+          req.destroy();
+          resolve({ statusCode: null, success: false, error: 'Timeout' });
+        });
+      });
+    } catch (error) {
+      return { statusCode: null, success: false, error: error.message };
+    }
+  }
+
   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 });
-          });
-        });
+        const result = await HealthCheck.makeHttpRequest(url, 5000);
 
-        if (result.code === 0 && result.output === '200') {
+        if (result.success && result.statusCode === 200) {
           !silent && this.logger.success(`${url} is available`);
           return true;
         }

package/lib/orchestrator.js

@@ -179,6 +179,16 @@ export class Orchestrator {
 
     if (commandFailed) {
       this.failedCommands.push(command);
+      
+      // Cleanup any background processes for this failed command
+      if (background) {
+        this.logger.warn(`Command ${command} failed after all attempts. Cleaning up background processes.`);
+        try {
+          await this.processManager.cleanupCommand(command);
+        } catch (cleanupError) {
+          this.logger.error(`Failed to cleanup processes for ${command}: ${cleanupError.message}`);
+        }
+      }
     }
 
     this.commandTimings.set(command, Date.now() - startTime);

package/lib/process-manager.js

@@ -2,6 +2,7 @@ import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import { log } from './logger.js';
+import { HealthCheck } from './health-check.js';
 
 
 export class ProcessManager {
@@ -75,6 +76,16 @@ export class ProcessManager {
           const processGroupId = processInstance.pid;
           this.logger.verbose(`Background process spawned with PID: ${processGroupId}`);
 
+          // Track process exit for background processes
+          let processExited = false;
+          let processExitCode = null;
+          
+          processInstance.on('exit', (code, signal) => {
+            processExited = true;
+            processExitCode = code;
+            this.logger.verbose(`Background process ${cmd} (PID: ${processGroupId}) exited with code: ${code}, signal: ${signal}`);
+          });
+
           processInstance.stdout.on('data', (data) => {
             try {
               fs.appendFileSync(LOG_FILE, data.toString());
@@ -97,10 +108,39 @@ export class ProcessManager {
 
             for (let attempt = 1; attempt <= maxAttempts; attempt++) {
               try {
+                // First check if the process has already exited with an error
+                if (processExited && processExitCode !== 0) {
+                  this.logger.error(`Background process ${cmd} exited with code ${processExitCode}`);
+                  let output = '';
+                  try {
+                    output = fs.readFileSync(LOG_FILE, 'utf8');
+                    this.logger.verbose(`Process output: ${output}`);
+                  } catch (error) {
+                    this.logger.error(`Failed to read log file: ${error.message}`);
+                  }
+                  return { success: false, output };
+                }
+                
                 this.logger.verbose(`Verifying process ${processGroupId} (attempt ${attempt}/${maxAttempts})`);
                 process.kill(processGroupId, 0);
                 this.logger.verbose(`Process ${processGroupId} is running`);
                 
+                // Wait a bit more to ensure the process doesn't exit immediately after verification
+                await new Promise((resolve) => setTimeout(resolve, 500));
+                
+                // Check again if the process exited during our wait
+                if (processExited && processExitCode !== 0) {
+                  this.logger.error(`Background process ${cmd} exited with code ${processExitCode} shortly after starting`);
+                  let output = '';
+                  try {
+                    output = fs.readFileSync(LOG_FILE, 'utf8');
+                    this.logger.verbose(`Process output: ${output}`);
+                  } catch (error) {
+                    this.logger.error(`Failed to read log file: ${error.message}`);
+                  }
+                  return { success: false, output };
+                }
+                
                 this.backgroundProcesses.push(processGroupId);
                 this.backgroundProcessesDetails.push({
                   command: cmd,
@@ -218,139 +258,235 @@ export class ProcessManager {
     
     const killPromises = this.backgroundProcessesDetails.map(
       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`,
-          );
-          return;
-        }
+        await this.cleanupProcess({ command, pgid, url, startedByScript, kill_command });
+      },
+    );
 
-        this.logger.verbose(`- Processing cleanup for ${command} (kill_command: ${kill_command})`);
+    await Promise.all(killPromises);
+    this.backgroundProcesses = [];
+    this.backgroundProcessesDetails = [];
+  }
 
-        // 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`);
-          }
+  async cleanupCommand(commandName) {
+    this.logger.info(`\nCleaning up processes for command: ${commandName}`);
+    
+    // Find processes for this specific command
+    const commandProcesses = this.backgroundProcessesDetails.filter(
+      ({ command }) => command === commandName
+    );
+    
+    if (commandProcesses.length === 0) {
+      this.logger.verbose(`- No background processes found for command: ${commandName}`);
+      return;
+    }
+    
+    this.logger.verbose(`- Found ${commandProcesses.length} background processes for command: ${commandName}`);
+    
+    const killPromises = commandProcesses.map(
+      async ({ command, pgid, url, startedByScript, kill_command }) => {
+        await this.cleanupProcess({ command, pgid, url, startedByScript, kill_command });
+      }
+    );
+
+    await Promise.all(killPromises);
+    
+    // Remove the cleaned up processes from our tracking arrays
+    this.backgroundProcesses = this.backgroundProcesses.filter(pgid => 
+      !commandProcesses.some(proc => proc.pgid === pgid)
+    );
+    this.backgroundProcessesDetails = this.backgroundProcessesDetails.filter(
+      ({ command }) => command !== commandName
+    );
+  }
+
+  async cleanupProcess({ command, pgid, url, startedByScript, kill_command }) {
+    if (!startedByScript) {
+      this.logger.verbose(
+        `- Skipping cleanup for ${command} (${url}) as it was not started by this script`,
+      );
+      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(`- No kill_command specified for ${command}, using process signals`);
+          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 {
+        process.kill(pgid, 0);
+      } catch (error) {
+        this.logger.verbose(
+          `- Process ${command} (PGID: ${pgid}) already terminated`,
+        );
+        return;
+      }
 
+      // Cross-platform process termination
+      const isWindows = process.platform === 'win32';
+      
+      if (isWindows) {
+        // Windows: use taskkill to terminate process tree
         try {
-          // First try to kill the process group
+          const killProcess = spawn('taskkill', ['/F', '/T', '/PID', pgid.toString()]);
+          await new Promise((resolve) => {
+            killProcess.on('close', resolve);
+          });
+          this.logger.verbose(`- Terminated background process: ${command} (PID: ${pgid})`);
+          return;
+        } catch (killError) {
+          this.logger.verbose(`- Failed to use taskkill, falling back to process.kill: ${killError.message}`);
+        }
+      }
+      
+      // Unix/Linux/macOS or Windows fallback: 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) {
-            this.logger.verbose(
-              `- Process ${command} (PGID: ${pgid}) already terminated`,
-            );
-            return;
+            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}`);
+    }
 
-          // 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) {
+    // 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');
+        
+        // Use shared HTTP utility for cross-platform compatibility
+        const urlResult = await HealthCheck.makeHttpRequest(url, 2000);
+        
+        if (urlResult.success && urlResult.statusCode === 200) {
+          this.logger.verbose(`- URL ${url} is still responding after termination, finding process on port ${port}`);
+          
+          // Find and kill process using the port - cross-platform approach
           try {
-            const urlObj = new URL(url);
-            const port = urlObj.port || (urlObj.protocol === 'https:' ? '443' : '80');
+            const isWindows = process.platform === 'win32';
+            let findPortCmd, findPortArgs;
             
-            const curl = spawn('curl', ['-s', '-o', '/dev/null', '-w', '%{http_code}', url]);
+            if (isWindows) {
+              // Windows: use netstat
+              findPortCmd = 'netstat';
+              findPortArgs = ['-ano'];
+            } else {
+              // Unix/Linux/macOS: use lsof
+              findPortCmd = 'lsof';
+              findPortArgs = ['-i', `:${port}`, '-t'];
+            }
+            
+            const findProcess = spawn(findPortCmd, findPortArgs);
             const result = await new Promise((resolve) => {
               let output = '';
-              curl.stdout.on('data', (data) => {
+              findProcess.stdout.on('data', (data) => {
                 output += data.toString();
               });
-              curl.on('close', (code) => {
+              findProcess.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}`);
+            if (result.code === 0 && result.output.trim()) {
+              let pids = [];
               
-              // 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}`);
-                      }
+              if (isWindows) {
+                // Parse netstat output to find PIDs for the specific port
+                const lines = result.output.split('\n');
+                for (const line of lines) {
+                  if (line.includes(`:${port} `) && line.includes('LISTENING')) {
+                    const parts = line.trim().split(/\s+/);
+                    const pid = parts[parts.length - 1];
+                    if (pid && !isNaN(pid)) {
+                      pids.push(pid);
                     }
                   }
                 }
-              } catch (lsofError) {
-                this.logger.error(`- Failed to find process using port ${port}: ${lsofError.message}`);
+              } else {
+                // lsof output is already just PIDs
+                pids = result.output.trim().split('\n');
+              }
+              
+              for (const pid of pids) {
+                try {
+                  if (isWindows) {
+                    // Windows: use taskkill
+                    const killProcess = spawn('taskkill', ['/F', '/PID', pid]);
+                    await new Promise((resolve) => {
+                      killProcess.on('close', resolve);
+                    });
+                  } else {
+                    // Unix/Linux/macOS: use process.kill
+                    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 (error) {
-            this.logger.verbose(`- URL check failed: ${error.message}`);
+          } catch (portError) {
+            this.logger.error(`- Failed to find process using port ${port}: ${portError.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 = [];
+    // Final attempt to kill the process group
+    try {
+      const isWindows = process.platform === 'win32';
+      
+      if (isWindows) {
+        // Windows: force kill with taskkill
+        const killProcess = spawn('taskkill', ['/F', '/T', '/PID', pgid.toString()]);
+        await new Promise((resolve) => {
+          killProcess.on('close', resolve);
+        });
+      } else {
+        // Unix/Linux/macOS: use SIGKILL
+        process.kill(pgid, 'SIGKILL');
+      }
+    } catch (error) {
+      if (error.code !== 'ESRCH') {
+        this.logger.error(`- Failed to kill process group: ${error.message}`);
+      }
+    }
   }
 }
 

package/package.json

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