go-dev 0.4.0 → 0.4.2

package/package.json

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

package/src/config.js

@@ -1,7 +1,6 @@
 const Joi = require('joi');
 const yaml = require('js-yaml');
 const fs = require('fs');
-const path = require('path');
 
 const dependencyEntrySchema = Joi.alternatives().try(
   Joi.string(),

package/src/prefix-lines.js

@@ -1,9 +1,9 @@
-const detectLatestColor = require("./detect-last-color");
+const detectLastFormatting = require("./terminal-formatting/detect-last-formatting");
 
-function prefixLines(text, prefix, latestColor) {
+function prefixLines(text, prefix, latestFormatting) {
   let prefixedText = text.split('\n').map(line => {
-    latestColor = detectLatestColor(line, latestColor);
-    return `${prefix} ${latestColor}${line}${latestColor !== '' ? '\x1b[0m' : ''}`;
+    latestFormatting = detectLastFormatting(line, latestFormatting);
+    return `${prefix} ${latestFormatting}${line}${latestFormatting !== '' ? '\x1b[0m' : ''}`;
   }).join('\n');
 
   if (prefixedText.endsWith(`${prefix} `)) {
@@ -14,7 +14,7 @@ function prefixLines(text, prefix, latestColor) {
   }
   prefixedText = prefixedText.replace(/\x1b\[(?:2J|3J|H)|\x1bc|\x1b\[2K|\x1b\[K/gi, '');
 
-  return { prefixedText, latestColor };
+  return { prefixedText, lastFormatting: latestFormatting };
 }
 
 module.exports = prefixLines;

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();
@@ -119,15 +121,15 @@ class ProcessManager {
     });
     processReference.process = startedProcess;
 
-    let latestColor = '';
+    let lastFormatting = '';
     startedProcess.stdout.on('data', (data) => {
-      const result = prefixLines(data.toString(), prefix, latestColor);
-      latestColor = result.latestColor;
+      const result = prefixLines(data.toString(), prefix, lastFormatting);
+      lastFormatting = result.lastFormatting;
       process.stdout.write(result.prefixedText);
     });
     startedProcess.stderr.on('data', (data) => {
-      const result = prefixLines(data.toString(), prefix, latestColor);
-      latestColor = result.latestColor;
+      const result = prefixLines(data.toString(), prefix, lastFormatting);
+      lastFormatting = result.lastFormatting;
       process.stderr.write(result.prefixedText);
     });
 
@@ -176,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();
       }
     });
   }
@@ -229,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}`);
+        }
       }
     }
 

package/src/terminal-formatting/apply-formatting-codes.js

@@ -0,0 +1,223 @@
+const {
+  RESET_ALL,
+  RESET_FOREGROUND,
+  RESET_BACKGROUND,
+
+  SET_BOLD,
+  SET_DIM,
+  SET_ITALIC,
+  SET_UNDERLINE,
+  SET_SLOW_BLINK,
+  SET_RAPID_BLINK,
+  SET_REVERSE,
+  SET_HIDE,
+  SET_STRIKETHROUGH,
+  SET_DOUBLE_UNDERLINE,
+
+  RESET_BOLD_DIM,
+  RESET_ITALIC,
+  RESET_UNDERLINE,
+  RESET_BLINK,
+  RESET_REVERSE,
+  RESET_HIDE,
+  RESET_STRIKETHROUGH,
+
+  SET_FG_BLACK,
+  SET_FG_RED,
+  SET_FG_GREEN,
+  SET_FG_YELLOW,
+  SET_FG_BLUE,
+  SET_FG_MAGENTA,
+  SET_FG_CYAN,
+  SET_FG_WHITE,
+
+  SET_BG_BLACK,
+  SET_BG_RED,
+  SET_BG_GREEN,
+  SET_BG_YELLOW,
+  SET_BG_BLUE,
+  SET_BG_MAGENTA,
+  SET_BG_CYAN,
+  SET_BG_WHITE,
+
+  SET_FG_BRIGHT_BLACK,
+  SET_FG_BRIGHT_RED,
+  SET_FG_BRIGHT_GREEN,
+  SET_FG_BRIGHT_YELLOW,
+  SET_FG_BRIGHT_BLUE,
+  SET_FG_BRIGHT_MAGENTA,
+  SET_FG_BRIGHT_CYAN,
+  SET_FG_BRIGHT_WHITE,
+
+  SET_BG_BRIGHT_BLACK,
+  SET_BG_BRIGHT_RED,
+  SET_BG_BRIGHT_GREEN,
+  SET_BG_BRIGHT_YELLOW,
+  SET_BG_BRIGHT_BLUE,
+  SET_BG_BRIGHT_MAGENTA,
+  SET_BG_BRIGHT_CYAN,
+  SET_BG_BRIGHT_WHITE,
+
+  SET_FG_COLOR,
+  SET_BG_COLOR,
+
+  COLOR_MODE_256,
+  COLOR_MODE_RGB,
+
+  FOREGROUND_INDEX,
+  BACKGROUND_INDEX,
+  BOLD_DIM_INDEX,
+  ITALIC_INDEX,
+  UNDERLINE_INDEX,
+  BLINK_INDEX,
+  REVERSE_INDEX,
+  HIDE_INDEX,
+  STRIKETHROUGH_INDEX,
+} = require("./constants");
+
+function applyFormattingCodes(currentCodes, codes) {
+  for (let i = 0; i < codes.length; i++) {
+    const code = codes[i];
+    switch (code) {
+      case RESET_ALL: {
+        currentCodes.splice(0);
+        break;
+      }
+      case RESET_FOREGROUND: {
+        currentCodes[FOREGROUND_INDEX] = undefined;
+        break;
+      }
+      case RESET_BACKGROUND: {
+        currentCodes[BACKGROUND_INDEX] = undefined;
+        break;
+      }
+      case RESET_BOLD_DIM: {
+        currentCodes[BOLD_DIM_INDEX] = undefined;
+        break;
+      }
+      case RESET_ITALIC: {
+        currentCodes[ITALIC_INDEX] = undefined;
+        break;
+      }
+      case RESET_UNDERLINE: {
+        currentCodes[UNDERLINE_INDEX] = undefined;
+        break;
+      }
+      case RESET_BLINK: {
+        currentCodes[BLINK_INDEX] = undefined;
+        break;
+      }
+      case RESET_REVERSE: {
+        currentCodes[REVERSE_INDEX] = undefined;
+        break;
+      }
+      case RESET_HIDE: {
+        currentCodes[HIDE_INDEX] = undefined;
+        break;
+      }
+      case RESET_STRIKETHROUGH: {
+        currentCodes[STRIKETHROUGH_INDEX] = undefined;
+        break;
+      }
+      case SET_FG_BLACK:
+      case SET_FG_RED:
+      case SET_FG_GREEN:
+      case SET_FG_YELLOW:
+      case SET_FG_BLUE:
+      case SET_FG_MAGENTA:
+      case SET_FG_CYAN:
+      case SET_FG_WHITE:
+      case SET_FG_BRIGHT_BLACK:
+      case SET_FG_BRIGHT_RED:
+      case SET_FG_BRIGHT_GREEN:
+      case SET_FG_BRIGHT_YELLOW:
+      case SET_FG_BRIGHT_BLUE:
+      case SET_FG_BRIGHT_MAGENTA:
+      case SET_FG_BRIGHT_CYAN:
+      case SET_FG_BRIGHT_WHITE:
+      case SET_FG_COLOR: {
+        if (code === SET_FG_COLOR) {
+          const nextCode = codes[i + 1];
+          let finalCode = `${code};${nextCode}`;
+          if (nextCode === COLOR_MODE_256) {
+            finalCode = `${finalCode};${codes[i + 2]}`;
+            i += 2;
+          } else {
+            finalCode = `${finalCode};${codes[i + 2]};${codes[i + 3]};${codes[i + 4]}`;
+            i += 4;
+          }
+          currentCodes[FOREGROUND_INDEX] = finalCode;
+        } else {
+          currentCodes[FOREGROUND_INDEX] = code;
+        }
+        break;
+      }
+      case SET_BG_BLACK:
+      case SET_BG_RED:
+      case SET_BG_GREEN:
+      case SET_BG_YELLOW:
+      case SET_BG_BLUE:
+      case SET_BG_MAGENTA:
+      case SET_BG_CYAN:
+      case SET_BG_WHITE:
+      case SET_BG_BRIGHT_BLACK:
+      case SET_BG_BRIGHT_RED:
+      case SET_BG_BRIGHT_GREEN:
+      case SET_BG_BRIGHT_YELLOW:
+      case SET_BG_BRIGHT_BLUE:
+      case SET_BG_BRIGHT_MAGENTA:
+      case SET_BG_BRIGHT_CYAN:
+      case SET_BG_BRIGHT_WHITE:
+      case SET_BG_COLOR: {
+        if (code === SET_BG_COLOR) {
+          const nextCode = codes[i + 1];
+          let finalCode = `${code};${nextCode}`;
+          if (nextCode === COLOR_MODE_256) {
+            finalCode = `${finalCode};${codes[i + 2]}`;
+            i += 2;
+          } else {
+            finalCode = `${finalCode};${codes[i + 2]};${codes[i + 3]};${codes[i + 4]}`;
+            i += 4;
+          }
+          currentCodes[BACKGROUND_INDEX] = finalCode;
+        } else {
+          currentCodes[BACKGROUND_INDEX] = code;
+        }
+        break;
+      }
+      case SET_BOLD:
+      case SET_DIM: {
+        currentCodes[BOLD_DIM_INDEX] = code;
+        break;
+      }
+      case SET_ITALIC: {
+        currentCodes[ITALIC_INDEX] = code;
+        break;
+      }
+      case SET_UNDERLINE:
+      case SET_DOUBLE_UNDERLINE: {
+        currentCodes[UNDERLINE_INDEX] = code;
+        break;
+      }
+      case SET_SLOW_BLINK:
+      case SET_RAPID_BLINK: {
+        currentCodes[BLINK_INDEX] = code;
+        break;
+      }
+      case SET_REVERSE: {
+        currentCodes[REVERSE_INDEX] = code;
+        break;
+      }
+      case SET_HIDE: {
+        currentCodes[HIDE_INDEX] = code;
+        break;
+      }
+      case SET_STRIKETHROUGH: {
+        currentCodes[STRIKETHROUGH_INDEX] = code;
+        break;
+      }
+    }
+  }
+}
+
+module.exports = applyFormattingCodes;

package/src/terminal-formatting/constants.js

@@ -0,0 +1,151 @@
+const RESET_ALL = "0";
+const RESET_FOREGROUND = "39";
+const RESET_BACKGROUND = "49";
+
+const SET_BOLD = "1";
+const SET_DIM = "2";
+const SET_ITALIC = "3";
+const SET_UNDERLINE = "4";
+const SET_SLOW_BLINK = "5";
+const SET_RAPID_BLINK = "6";
+const SET_REVERSE = "7";
+const SET_HIDE = "8";
+const SET_STRIKETHROUGH = "9";
+const SET_DOUBLE_UNDERLINE = "21";
+
+const RESET_BOLD_DIM = "22";
+const RESET_ITALIC = "23";
+const RESET_UNDERLINE = "24";
+const RESET_BLINK = "25";
+const RESET_REVERSE = "27";
+const RESET_HIDE = "28";
+const RESET_STRIKETHROUGH = "29";
+
+const SET_FG_BLACK = "30";
+const SET_FG_RED = "31";
+const SET_FG_GREEN = "32";
+const SET_FG_YELLOW = "33";
+const SET_FG_BLUE = "34";
+const SET_FG_MAGENTA = "35";
+const SET_FG_CYAN = "36";
+const SET_FG_WHITE = "37";
+
+const SET_BG_BLACK = "40";
+const SET_BG_RED = "41";
+const SET_BG_GREEN = "42";
+const SET_BG_YELLOW = "43";
+const SET_BG_BLUE = "44";
+const SET_BG_MAGENTA = "45";
+const SET_BG_CYAN = "46";
+const SET_BG_WHITE = "47";
+
+const SET_FG_BRIGHT_BLACK = "90";
+const SET_FG_BRIGHT_RED = "91";
+const SET_FG_BRIGHT_GREEN = "92";
+const SET_FG_BRIGHT_YELLOW = "93";
+const SET_FG_BRIGHT_BLUE = "94";
+const SET_FG_BRIGHT_MAGENTA = "95";
+const SET_FG_BRIGHT_CYAN = "96";
+const SET_FG_BRIGHT_WHITE = "97";
+
+const SET_BG_BRIGHT_BLACK = "100";
+const SET_BG_BRIGHT_RED = "101";
+const SET_BG_BRIGHT_GREEN = "102";
+const SET_BG_BRIGHT_YELLOW = "103";
+const SET_BG_BRIGHT_BLUE = "104";
+const SET_BG_BRIGHT_MAGENTA = "105";
+const SET_BG_BRIGHT_CYAN = "106";
+const SET_BG_BRIGHT_WHITE = "107";
+
+const SET_FG_COLOR = "38";
+const SET_BG_COLOR = "48";
+
+const COLOR_MODE_256 = "5";
+const COLOR_MODE_RGB = "2";
+
+const FOREGROUND_INDEX = 0;
+const BACKGROUND_INDEX = 1;
+const BOLD_DIM_INDEX = 2;
+const ITALIC_INDEX = 3;
+const UNDERLINE_INDEX = 4;
+const BLINK_INDEX = 5;
+const REVERSE_INDEX = 6;
+const HIDE_INDEX = 7;
+const STRIKETHROUGH_INDEX = 8;
+
+module.exports = {
+  RESET_ALL,
+  RESET_FOREGROUND,
+  RESET_BACKGROUND,
+
+  SET_BOLD,
+  SET_DIM,
+  SET_ITALIC,
+  SET_UNDERLINE,
+  SET_SLOW_BLINK,
+  SET_RAPID_BLINK,
+  SET_REVERSE,
+  SET_HIDE,
+  SET_STRIKETHROUGH,
+  SET_DOUBLE_UNDERLINE,
+
+  RESET_BOLD_DIM,
+  RESET_ITALIC,
+  RESET_UNDERLINE,
+  RESET_BLINK,
+  RESET_REVERSE,
+  RESET_HIDE,
+  RESET_STRIKETHROUGH,
+
+  SET_FG_BLACK,
+  SET_FG_RED,
+  SET_FG_GREEN,
+  SET_FG_YELLOW,
+  SET_FG_BLUE,
+  SET_FG_MAGENTA,
+  SET_FG_CYAN,
+  SET_FG_WHITE,
+
+  SET_BG_BLACK,
+  SET_BG_RED,
+  SET_BG_GREEN,
+  SET_BG_YELLOW,
+  SET_BG_BLUE,
+  SET_BG_MAGENTA,
+  SET_BG_CYAN,
+  SET_BG_WHITE,
+
+  SET_FG_BRIGHT_BLACK,
+  SET_FG_BRIGHT_RED,
+  SET_FG_BRIGHT_GREEN,
+  SET_FG_BRIGHT_YELLOW,
+  SET_FG_BRIGHT_BLUE,
+  SET_FG_BRIGHT_MAGENTA,
+  SET_FG_BRIGHT_CYAN,
+  SET_FG_BRIGHT_WHITE,
+
+  SET_BG_BRIGHT_BLACK,
+  SET_BG_BRIGHT_RED,
+  SET_BG_BRIGHT_GREEN,
+  SET_BG_BRIGHT_YELLOW,
+  SET_BG_BRIGHT_BLUE,
+  SET_BG_BRIGHT_MAGENTA,
+  SET_BG_BRIGHT_CYAN,
+  SET_BG_BRIGHT_WHITE,
+
+  SET_FG_COLOR,
+  SET_BG_COLOR,
+
+  COLOR_MODE_256,
+  COLOR_MODE_RGB,
+
+  FOREGROUND_INDEX,
+  BACKGROUND_INDEX,
+  BOLD_DIM_INDEX,
+  ITALIC_INDEX,
+  UNDERLINE_INDEX,
+  BLINK_INDEX,
+  REVERSE_INDEX,
+  HIDE_INDEX,
+  STRIKETHROUGH_INDEX,
+};

package/src/terminal-formatting/detect-last-formatting.js

@@ -0,0 +1,10 @@
+const extractFormattingCodes = require("./extract-formatting-codes");
+
+function detectLastFormatting(text, latestFormatting) {
+  const currentFormattingCodes = extractFormattingCodes(latestFormatting);
+  const latestFormattingCodes = extractFormattingCodes(text, currentFormattingCodes);
+
+  return latestFormattingCodes.filter(code => code != null).map(code => `\x1b[${code}m`).join("");
+}
+
+module.exports = detectLastFormatting;

package/src/terminal-formatting/extract-formatting-codes.js

@@ -0,0 +1,26 @@
+const applyFormattingCodes = require("./apply-formatting-codes");
+
+function extractFormattingCodes(text, currentFormattingCodes = []) {
+  const colorRegex = /\x1b\[[0-9;]*m/g;
+  const matches = text.match(colorRegex);
+  if (matches == null || matches.length <= 0) {
+    return [];
+  }
+
+  for (const match of matches) {
+    const formattingCodes = match.slice(2, -1).split(";");
+    if (
+      formattingCodes.length === 1 &&
+      formattingCodes[0] === ""
+    ) {
+      currentFormattingCodes.splice(0);
+      continue;
+    }
+
+    applyFormattingCodes(currentFormattingCodes, formattingCodes);
+  }
+
+  return currentFormattingCodes;
+}
+
+module.exports = extractFormattingCodes;

package/src/detect-last-color.js

@@ -1,20 +0,0 @@
-function detectLatestColor(text, latestColor) {
-  const colorRegex = /\x1b\[[0-9;]*m/g;
-  const matches = text.match(colorRegex);
-  
-  if (matches == null || matches.length <= 0) {
-    return latestColor;
-  }
-
-  for (const match of matches) {
-    if (match === '\x1b[0m' || match === '\x1b[m') {
-      latestColor = '';
-    } else if (!latestColor.includes(match)) {
-      latestColor += match;
-    }
-  }
-
-  return latestColor;
-}
-
-module.exports = detectLatestColor;