go-dev 0.4.1 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "go-dev",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "main": "src/index.js",
   "bin": {
     "go-dev": "bin/go-dev"

package/src/process-manager.js

@@ -1,6 +1,8 @@
-const { spawn, spawnSync } = require('child_process');
+const { spawn, spawnSync, execSync } = require('child_process');
 const prefixLines = require("./prefix-lines");
 
+const isWindows = process.platform === 'win32';
+
 class ProcessManager {
   constructor() {
     this.managedProcesses = new Set();
@@ -123,13 +125,11 @@ class ProcessManager {
     startedProcess.stdout.on('data', (data) => {
       const result = prefixLines(data.toString(), prefix, lastFormatting);
       lastFormatting = result.lastFormatting;
-      // process.stdout.write(JSON.stringify(data.toString()) + "\n");
       process.stdout.write(result.prefixedText);
     });
     startedProcess.stderr.on('data', (data) => {
       const result = prefixLines(data.toString(), prefix, lastFormatting);
       lastFormatting = result.lastFormatting;
-      // process.stderr.write(JSON.stringify(data.toString()) + "\n");
       process.stderr.write(result.prefixedText);
     });
 
@@ -178,47 +178,65 @@ class ProcessManager {
     return processReference;
   }
 
-  killProcess(process) {
-    if (process.killed || process.exitCode != null) {
-      return;
+  /**
+   * Kills a single child process.
+   * On Windows, uses taskkill to kill the entire process tree.
+   * @param {ChildProcess} childProcess - The process to kill.
+   * @returns {Promise<void>}
+   */
+  killProcess(childProcess) {
+    if (childProcess.killed || childProcess.exitCode != null) {
+      return Promise.resolve();
     }
 
-    this.managedProcesses.delete(process);
+    this.managedProcesses.delete(childProcess);
 
-    return new Promise((resolve, reject) => {
+    if (isWindows) {
+      try {
+        execSync(`taskkill /T /F /PID ${childProcess.pid}`, { stdio: 'ignore' });
+      } catch {
+        // Process may have already been terminated by Ctrl+C signal propagation - this is OK
+      }
+      return Promise.resolve();
+    }
+
+    // On Unix, use SIGTERM with timeout fallback to SIGKILL
+    return new Promise((resolve) => {
       let exited = false;
+      let timeoutId = null;
+      
       const onExit = () => {
         exited = true;
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
         resolve();
       };
-      process.on('exit', onExit);
+      childProcess.on('exit', onExit);
 
-      setTimeout(() => {
+      timeoutId = setTimeout(() => {
         if (exited) {
           return;
         }
 
-        console.error(`[ProcessManager] Timeout reached for process interruption ${process.pid}`);
+        console.error(`[ProcessManager] Timeout reached for process interruption ${childProcess.pid}`);
         try {
-          process.kill('SIGKILL');
+          childProcess.kill('SIGKILL');
         } catch (e) {
-          console.error(`[ProcessManager] Error force killing process ${process.pid}: ${e.message}`);
-          reject(e);
+          console.error(`[ProcessManager] Error force killing process ${childProcess.pid}: ${e.message}`);
         }
+        resolve();
       }, 500);
 
       try {
-        process.kill('SIGTERM');
-        return;
-      } catch (e) {
-        console.error(`[ProcessManager] Error signaling process ${process.pid}: ${e.message}`);
-      }
-
-      try {
-        process.kill('SIGKILL');
+        childProcess.kill('SIGTERM');
       } catch (e) {
-        console.error(`[ProcessManager] Error force killing process ${process.pid}: ${e.message}`);
-        reject(e);
+        console.error(`[ProcessManager] Error signaling process ${childProcess.pid}: ${e.message}`);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        resolve();
       }
     });
   }
@@ -231,41 +249,54 @@ class ProcessManager {
       console.log('[ProcessManager] Cleanup of managed processes already in progress, skipping.');
       return;
     }
-    for (let index = this.managedProcesses.length - 1; index >= 0; index--) {
-      const process = this.managedProcesses[index];
-      if (process.killed || process.exitCode != null) {
-        this.managedProcesses.splice(index, 1);
-      }
-    }
 
     this.cleanupInProgress = true;
 
     console.log('\n[ProcessManager] Initiating cleanup of managed processes...');
 
-    for (const proc of [...this.managedProcesses]) {
+    // Filter out already-dead processes
+    const processesToKill = [...this.managedProcesses].filter(proc => {
       if (proc.killed || proc.exitCode != null) {
-        continue;
+        this.managedProcesses.delete(proc);
+        return false;
       }
-
+      return true;
+    });
+    
+    for (const proc of processesToKill) {
       console.log(`[ProcessManager] Killing managed process PID: ${proc.pid}`);
       try {
-        proc.kill('SIGTERM');
+        if (isWindows) {
+          // On Windows, use taskkill to kill the entire process tree
+          try {
+            execSync(`taskkill /T /F /PID ${proc.pid}`, { stdio: 'ignore' });
+          } catch {
+            // Process may have already been terminated - this is OK
+          }
+        } else {
+          proc.kill('SIGTERM');
+        }
       } catch (e) {
         console.error(`[ProcessManager] Error killing process ${proc.pid}: ${e.message}`);
       }
     }
-    await new Promise(resolve => setTimeout(resolve, 500));
-
-    for (const proc of [...this.managedProcesses]) {
-      if (proc.killed || proc.exitCode != null) {
-        continue;
-      }
+    
+    // On Unix, wait for processes to exit gracefully before using SIGKILL
+    if (processesToKill.length > 0 && !isWindows) {
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      for (const proc of [...this.managedProcesses]) {
+        if (proc.killed || proc.exitCode != null) {
+          this.managedProcesses.delete(proc);
+          continue;
+        }
 
-      console.warn(`[ProcessManager] Process ${proc.pid} did not exit gracefully, forcing kill.`);
-      try {
-        proc.kill('SIGKILL');
-      } catch (e) {
-        console.error(`[ProcessManager] Error forcing kill for process ${proc.pid}: ${e.message}`);
+        console.warn(`[ProcessManager] Process ${proc.pid} did not exit gracefully, forcing kill.`);
+        try {
+          proc.kill('SIGKILL');
+        } catch (e) {
+          console.error(`[ProcessManager] Error forcing kill for process ${proc.pid}: ${e.message}`);
+        }
       }
     }