scripts-orchestrator 2.10.0 → 2.13.0

package/lib/process-manager.js

@@ -4,7 +4,6 @@ import path from 'path';
 import { log } from './logger.js';
 import { HealthCheck } from './health-check.js';
 
-
 export class ProcessManager {
   constructor() {
     this.logger = log;
@@ -13,20 +12,39 @@ export class ProcessManager {
     this.logFolder = 'scripts-orchestrator-logs'; // Default log folder
   }
 
+  formatDuration(ms) {
+    if (ms < 1000) return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes > 0) {
+      return `${minutes}m ${remainingSeconds}s`;
+    }
+    return `${seconds}s`;
+  }
+
   setLogFolder(logFolder) {
     this.logFolder = logFolder;
     this.logger.verbose(`Log folder set to: ${logFolder}`);
   }
 
   getLogPath(command) {
-    const baseDir = this.logFolder ? path.resolve(this.logFolder) : process.cwd();
+    const baseDir = this.logFolder
+      ? path.resolve(this.logFolder)
+      : process.cwd();
     const LOGS_DIR = path.join(baseDir, 'scripts-orchestrator-logs');
     // Use only the first word of the command for the log filename
     const logName = command.split(/\s+/)[0];
     return path.join(LOGS_DIR, `${logName}.log`);
   }
 
-  addBackgroundProcess({ command, url, startedByScript, process_tracking, kill_command }) {
+  addBackgroundProcess({
+    command,
+    url,
+    startedByScript,
+    process_tracking,
+    kill_command,
+  }) {
     this.logger.verbose(`Adding background process: ${command} (${url})`);
     this.backgroundProcessesDetails.push({
       command,
@@ -37,8 +55,46 @@ export class ProcessManager {
     });
   }
 
-  async runCommand({ cmd, logFile, background = false, healthCheck = null, kill_command = null, isRetry = false, env = null }) {
-    const baseDir = this.logFolder ? path.resolve(this.logFolder) : process.cwd();
+  parseGnuTimeOutput(filePath) {
+    try {
+      if (!fs.existsSync(filePath)) return null;
+      const text = fs.readFileSync(filePath, 'utf8');
+      const m = text.match(/Maximum resident set size \(kbytes\):\s*(\d+)/i);
+      const kbytes = m ? parseInt(m[1], 10) : null;
+      try {
+        fs.unlinkSync(filePath);
+      } catch {
+        // ignore
+      }
+      return Number.isFinite(kbytes) ? kbytes : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Parse macOS BSD time -l output (bytes) from text; returns memory in KB or null. */
+  parseBsdTimeOutput(text) {
+    if (!text || typeof text !== 'string') return null;
+    const m = text.match(/(\d+)\s+maximum resident set size/i);
+    if (!m) return null;
+    const bytes = parseInt(m[1], 10);
+    return Number.isFinite(bytes) ? Math.round(bytes / 1024) : null;
+  }
+
+  async runCommand({
+    cmd,
+    logFile,
+    background = false,
+    healthCheck = null,
+    kill_command = null,
+    isRetry = false,
+    env = null,
+    reportTime = false,
+    reportMemory = false,
+  }) {
+    const baseDir = this.logFolder
+      ? path.resolve(this.logFolder)
+      : process.cwd();
     const LOGS_DIR = path.join(baseDir, 'scripts-orchestrator-logs');
     // Use only the first word of the command for the log filename
     const logName = cmd.split(/\s+/)[0];
@@ -54,26 +110,45 @@ export class ProcessManager {
         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)`);
+        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: '' });
+      return Promise.resolve({
+        success: false,
+        output: '',
+        durationMs: 0,
+        memoryKb: null,
+      });
     }
 
     return new Promise((resolve) => {
+      const startTime = Date.now();
+      let timeOutputPath = null;
       // Build command with environment variables if provided
       let fullCommand = `npm run ${cmd}`;
       if (env && Object.keys(env).length > 0) {
-        const envStr = Object.entries(env).map(([key, value]) => `${key}=${value}`).join(' ');
+        const envStr = Object.entries(env)
+          .map(([key, value]) => `${key}=${value}`)
+          .join(' ');
         fullCommand = `${envStr} npm run ${cmd}`;
       }
-      
-      this.logger.info(`Running: ${fullCommand}`);
-      
+      const useTimeWrapper =
+        reportMemory && !background && (process.platform === 'linux' || process.platform === 'darwin');
+      if (useTimeWrapper && process.platform === 'linux') {
+        timeOutputPath = path.join(LOGS_DIR, `.time-${logName}-${startTime}.txt`);
+        fullCommand = `/usr/bin/time -v -o ${JSON.stringify(timeOutputPath)} sh -c ${JSON.stringify(fullCommand)}`;
+      } else if (useTimeWrapper && process.platform === 'darwin') {
+        fullCommand = `/usr/bin/time -l sh -c ${JSON.stringify(fullCommand)}`;
+      }
+
+      this.logger.startTask(cmd, fullCommand);
+
       // Create isolated environment for each process
       const isolatedEnv = this.createIsolatedEnvironment({ command: cmd, env });
-      
+
       const options = {
         shell: true,
         detached: background,
@@ -91,30 +166,41 @@ export class ProcessManager {
         const processInstance = spawn(fullCommand, [], options);
 
         processInstance.on('error', (error) => {
+          this.logger.stopTask(cmd);
           this.logger.error(`Failed to start process: ${error.message}`);
-          //this.logger.verbose(`Process error details: ${JSON.stringify(error, null, 2)}`);
-          resolve({ success: false, output: '' });
+          resolve({
+            success: false,
+            output: '',
+            durationMs: Date.now() - startTime,
+            memoryKb: null,
+          });
         });
 
         if (background) {
           const processGroupId = processInstance.pid;
-          this.logger.verbose(`Background process spawned with PID: ${processGroupId}`);
+          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}`);
+            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());
             } catch (error) {
-              this.logger.error(`Failed to write to log file: ${error.message}`);
+              this.logger.error(
+                `Failed to write to log file: ${error.message}`,
+              );
             }
           });
 
@@ -122,7 +208,9 @@ export class ProcessManager {
             try {
               fs.appendFileSync(LOG_FILE, data.toString());
             } catch (error) {
-              this.logger.error(`Failed to write to log file: ${error.message}`);
+              this.logger.error(
+                `Failed to write to log file: ${error.message}`,
+              );
             }
           });
 
@@ -134,37 +222,59 @@ export class ProcessManager {
               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}`);
+                  this.logger.stopTask(cmd);
+                  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}`);
+                    this.logger.error(
+                      `Failed to read log file: ${error.message}`,
+                    );
                   }
-                  return { success: false, output };
+                  return {
+                    success: false,
+                    output,
+                    durationMs: Date.now() - startTime,
+                    memoryKb: null,
+                  };
                 }
-                
-                this.logger.verbose(`Verifying process ${processGroupId} (attempt ${attempt}/${maxAttempts})`);
+
+                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`);
+                  this.logger.stopTask(cmd);
+                  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}`);
+                    this.logger.error(
+                      `Failed to read log file: ${error.message}`,
+                    );
                   }
-                  return { success: false, output };
+                  return {
+                    success: false,
+                    output,
+                    durationMs: Date.now() - startTime,
+                    memoryKb: null,
+                  };
                 }
-                
+
                 this.backgroundProcesses.push(processGroupId);
                 this.backgroundProcessesDetails.push({
                   command: cmd,
@@ -174,28 +284,52 @@ export class ProcessManager {
                   startedByScript: true,
                   kill_command,
                 });
-                
+
                 this.logger.verbose(`Unreferencing process ${processGroupId}`);
                 processInstance.unref();
-                
+
+                this.logger.stopTask(cmd);
                 this.logger.verbose(
                   `Background process started: npm run ${cmd} (PGID: ${processGroupId})`,
                 );
-                return { success: true, output: '' };
+                return {
+                  success: true,
+                  output: '',
+                  durationMs: Date.now() - startTime,
+                  memoryKb: null,
+                };
               } 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.error(
+                    `Failed to start background process: npm run ${cmd}`,
+                  );
+                  this.logger.verbose(
+                    `Final verification attempt failed: ${error.message}`,
+                  );
+                  return {
+                    success: false,
+                    output: '',
+                    durationMs: Date.now() - startTime,
+                    memoryKb: null,
+                  };
                 }
-                this.logger.verbose(`Verification attempt ${attempt} failed: ${error.message}`);
-                this.logger.verbose(`Waiting ${baseDelay * Math.pow(2, attempt - 1)}ms before next attempt`);
+                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: '' };
+            return {
+              success: false,
+              output: '',
+              durationMs: Date.now() - startTime,
+              memoryKb: null,
+            };
           };
 
           verifyProcess().then(resolve);
@@ -204,7 +338,9 @@ export class ProcessManager {
             try {
               fs.appendFileSync(LOG_FILE, data.toString());
             } catch (error) {
-              this.logger.error(`Failed to write to log file: ${error.message}`);
+              this.logger.error(
+                `Failed to write to log file: ${error.message}`,
+              );
             }
           });
 
@@ -212,7 +348,9 @@ export class ProcessManager {
             try {
               fs.appendFileSync(LOG_FILE, data.toString());
             } catch (error) {
-              this.logger.error(`Failed to write to log file: ${error.message}`);
+              this.logger.error(
+                `Failed to write to log file: ${error.message}`,
+              );
             }
           });
 
@@ -224,20 +362,52 @@ export class ProcessManager {
               this.logger.error(`Failed to read log file: ${error.message}`);
             }
 
+            this.logger.stopTask(cmd);
+
+            const durationMs = Date.now() - startTime;
+            const durationStr = reportTime
+              ? ` (${this.formatDuration(durationMs)})`
+              : '';
+            let memoryKb = null;
+            if (reportMemory) {
+              if (timeOutputPath) {
+                memoryKb = this.parseGnuTimeOutput(timeOutputPath);
+              } else if (process.platform === 'darwin') {
+                memoryKb = this.parseBsdTimeOutput(output);
+              }
+            }
+
             if (code !== 0) {
-              this.logger.error(`Failed: npm run ${cmd} (exit code: ${code})`);
+              this.logger.error(
+                `Failed: npm run ${cmd} ❌${durationStr} (exit code: ${code})`,
+              );
               this.logger.verbose(`Process output: ${output}`);
-              resolve({ success: false, output });
+              resolve({
+                success: false,
+                output,
+                durationMs,
+                memoryKb,
+              });
             } else {
-              this.logger.success(`Completed: npm run ${cmd}`);
-              resolve({ success: true, output });
+              this.logger.success(`Completed: npm run ${cmd} ✅${durationStr}`);
+              resolve({
+                success: true,
+                output,
+                durationMs,
+                memoryKb,
+              });
             }
           });
         }
       } catch (error) {
+        this.logger.stopTask(cmd);
         this.logger.error(`Failed to spawn process: ${error.message}`);
-        //this.logger.verbose(`Spawn error details: ${JSON.stringify(error, null, 2)}`);
-        resolve({ success: false, output: '' });
+        resolve({
+          success: false,
+          output: '',
+          durationMs: Date.now() - startTime,
+          memoryKb: null,
+        });
       }
     });
   }
@@ -245,7 +415,7 @@ export class ProcessManager {
   createIsolatedEnvironment({ command, env = null }) {
     // Create a deep copy to avoid any reference sharing
     const baseEnv = JSON.parse(JSON.stringify(process.env));
-    
+
     // Set standard environment variables
     const isolatedEnv = {
       ...baseEnv,
@@ -272,25 +442,37 @@ export class ProcessManager {
     // Remove any potentially problematic environment variables
     delete isolatedEnv.npm_lifecycle_event;
     delete isolatedEnv.npm_lifecycle_script;
-    
+
     return isolatedEnv;
   }
 
   async cleanup() {
     try {
       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`);
-    
+      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}`);
-      });
-    
+      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, kill_command }) => {
-          await this.cleanupProcess({ command, pgid, url, startedByScript, kill_command });
+          await this.cleanupProcess({
+            command,
+            pgid,
+            url,
+            startedByScript,
+            kill_command,
+          });
         },
       );
 
@@ -304,33 +486,43 @@ export class ProcessManager {
 
   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
+      ({ command }) => command === commandName,
     );
-    
+
     if (commandProcesses.length === 0) {
-      this.logger.verbose(`- No background processes found for command: ${commandName}`);
+      this.logger.verbose(
+        `- No background processes found for command: ${commandName}`,
+      );
       return;
     }
-    
-    this.logger.verbose(`- Found ${commandProcesses.length} background processes for command: ${commandName}`);
-    
+
+    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 this.cleanupProcess({
+          command,
+          pgid,
+          url,
+          startedByScript,
+          kill_command,
+        });
+      },
     );
 
     await Promise.allSettled(killPromises);
-    
+
     // Remove the cleaned up processes from our tracking arrays
-    this.backgroundProcesses = this.backgroundProcesses.filter(pgid => 
-      !commandProcesses.some(proc => proc.pgid === pgid)
+    this.backgroundProcesses = this.backgroundProcesses.filter(
+      (pgid) => !commandProcesses.some((proc) => proc.pgid === pgid),
     );
     this.backgroundProcessesDetails = this.backgroundProcessesDetails.filter(
-      ({ command }) => command !== commandName
+      ({ command }) => command !== commandName,
     );
   }
 
@@ -342,24 +534,40 @@ export class ProcessManager {
       return;
     }
 
-    this.logger.verbose(`- Processing cleanup for ${command} (kill_command: ${kill_command})`);
+    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 });
+        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`);
+          this.logger.verbose(
+            `- Successfully killed ${command} using custom command`,
+          );
           return;
         } else {
-          this.logger.verbose('- Custom kill command failed, falling back to 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`);
+        this.logger.verbose(
+          `- Custom kill command error: ${error.message}, falling back`,
+        );
       }
     } else {
-      this.logger.verbose(`- No kill_command specified for ${command}, using process signals`);
+      this.logger.verbose(
+        `- No kill_command specified for ${command}, using process signals`,
+      );
     }
 
     try {
@@ -375,27 +583,36 @@ export class ProcessManager {
 
       // Cross-platform process termination
       const isWindows = process.platform === 'win32';
-      
+
       if (isWindows) {
         // Windows: use taskkill to terminate process tree
         try {
-          const killProcess = spawn('taskkill', ['/F', '/T', '/PID', pgid.toString()]);
+          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})`);
+          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}`);
+          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) => {
         let timeout, checkInterval;
-        
+
         timeout = setTimeout(() => {
           if (checkInterval) clearInterval(checkInterval);
           reject(new Error('Process termination timeout'));
@@ -415,26 +632,31 @@ export class ProcessManager {
         `- Terminated background process: ${command} (PGID: ${pgid})`,
       );
     } catch (error) {
-      this.logger.verbose(`- Failed to terminate process group: ${error.message}`);
+      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 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}`);
-          
+          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 isWindows = process.platform === 'win32';
             let findPortCmd, findPortArgs;
-            
+
             if (isWindows) {
               // Windows: use netstat
               findPortCmd = 'netstat';
@@ -444,7 +666,7 @@ export class ProcessManager {
               findPortCmd = 'lsof';
               findPortArgs = ['-i', `:${port}`, '-t'];
             }
-            
+
             const findProcess = spawn(findPortCmd, findPortArgs);
             const result = await new Promise((resolve) => {
               let output = '';
@@ -458,12 +680,15 @@ export class ProcessManager {
 
             if (result.code === 0 && result.output.trim()) {
               let pids = [];
-              
+
               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')) {
+                  if (
+                    line.includes(`:${port} `) &&
+                    line.includes('LISTENING')
+                  ) {
                     const parts = line.trim().split(/\s+/);
                     const pid = parts[parts.length - 1];
                     if (pid && !isNaN(pid)) {
@@ -475,7 +700,7 @@ export class ProcessManager {
                 // lsof output is already just PIDs
                 pids = result.output.trim().split('\n');
               }
-              
+
               for (const pid of pids) {
                 try {
                   if (isWindows) {
@@ -488,16 +713,22 @@ export class ProcessManager {
                     // Unix/Linux/macOS: use process.kill
                     process.kill(parseInt(pid), 'SIGKILL');
                   }
-                  this.logger.verbose(`- Killed process (PID: ${pid}) using port ${port}`);
+                  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}`);
+                    this.logger.error(
+                      `- Failed to kill process (PID: ${pid}): ${killError.message}`,
+                    );
                   }
                 }
               }
             }
           } catch (portError) {
-            this.logger.error(`- Failed to find process using port ${port}: ${portError.message}`);
+            this.logger.error(
+              `- Failed to find process using port ${port}: ${portError.message}`,
+            );
           }
         }
       } catch (error) {
@@ -508,10 +739,15 @@ export class ProcessManager {
     // 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()]);
+        const killProcess = spawn('taskkill', [
+          '/F',
+          '/T',
+          '/PID',
+          pgid.toString(),
+        ]);
         await new Promise((resolve) => {
           killProcess.on('close', resolve);
         });
@@ -528,4 +764,4 @@ export class ProcessManager {
 }
 
 // For backward compatibility
-export const processManager = new ProcessManager();
+export const processManager = new ProcessManager();