go-dev 0.4.1 → 0.5.0

package/src/process-manager.js

@@ -1,276 +1,309 @@
-const { spawn, spawnSync } = require('child_process');
-const prefixLines = require("./prefix-lines");
-
-class ProcessManager {
-  constructor() {
-    this.managedProcesses = new Set();
-    this.cleanupInProgress = false;
-  }
-
-  /**
-   * Runs a command synchronously (blocking).
-   * Used for pre-commands, status checks, getting container names.
-   * @param {string} command - The command to execute.
-   * @param {string[]} args - Arguments for the command.
-   * @param {object} [options={}] - Options for spawnSync (e.g., cwd, stdio).
-   * @returns {string} The stdout of the command, trimmed.
-   * @throws {Error} If the command fails.
-   */
-  runSync(command, args = [], options = {}) {
-    if (this.cleanupInProgress) {
-      console.warn(`[ProcessManager] Skipping synchronous command '${command}' during cleanup.`);
-      return '';
-    }
-    console.log(`[ProcessManager] Running sync: ${command} ${args.join(' ')}`);
-    try {
-      const result = spawnSync(command, args, {
-        shell: true,
-        encoding: 'utf8',
-        ...options,
-      });
-
-      if (result.error) {
-        throw result.error;
-      }
-      if (result.status !== 0) {
-        const stderrOutput = result.stderr ? result.stderr.trim() : 'No stderr output.';
-        throw new Error(
-          `Command failed with code ${result.status}: ${command} ${args.join(
-            ' ',
-          )}\n${stderrOutput}`,
-        );
-      }
-      return result.stdout?.trim() ?? '';
-    } catch (error) {
-      throw new Error(`Failed to run sync command '${command}': ${error.message}`);
-    }
-  }
-
-  /**
-   * Runs a command asynchronously, inheriting stdio.
-   * Used for initial 'docker compose up -d' where we want to see immediate output
-   * and the process is not meant to be continually managed/restarted by the orchestrator.
-   * @param {string} command - The command to execute.
-   * @param {string[]} args - Arguments for the command.
-   * @param {object} [options={}] - Options for spawn.
-   * @returns {Promise<void>} A promise that resolves when the process exits successfully.
-   */
-  runInherited(command, args = [], options = {}) {
-    return new Promise((resolve, reject) => {
-      if (this.cleanupInProgress) {
-        console.warn(`[ProcessManager] Skipping inherited command '${command}' during cleanup.`);
-        return resolve();
-      }
-      console.log(`[ProcessManager] Running inherited: ${command} ${args.join(' ')}`);
-      const proc = spawn(command, args, {
-        shell: true,
-        stdio: 'inherit',
-        ...options,
-      });
-
-      proc.on('error', (err) => {
-        console.error(`[ProcessManager] Failed to start inherited command '${command}':`, err);
-        reject(err);
-      });
-
-      proc.on('exit', (code) => {
-        if (code !== 0) {
-          reject(
-            new Error(`Inherited command '${command}' exited with code ${code}`),
-          );
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-
-  /**
-   * Starts a long-running, managed process (like 'npx rollup -w').
-   * Its output is prefixed, and it can be configured to restart on exit.
-   * @param {string} command - The command to execute.
-   * @param {string[]} args - Arguments for the command.
-   * @param {object} options - Options for spawn (e.g., cwd).
-   * @param {string} prefix - Prefix for stdout/stderr lines (e.g., 'frontend:').
-   * @param {boolean} restartOnError - Whether to restart the process if it exits with non-zero code.
-   * @param {Function} onExit
-   * @param {ChildProcess[] | undefined} processReference - An array where to save the process to gain a reference to it.
-   * @returns {ChildProcess} The spawned child process instance.
-   */
-  startManagedProcess(command, args, options, prefix, restartOnError, onExit, processReference) {
-    if (this.cleanupInProgress) {
-      console.warn(`[ProcessManager] Skipping managed process '${command}' during cleanup.`);
-      return null;
-    }
-    console.log(
-      `[ProcessManager] Starting managed process: ${command} ${args.join(
-        ' ',
-      )} (prefix: ${prefix})`,
-    );
-
-    if (processReference == null) {
-      processReference = {}
-    }
-
-    const startedProcess = spawn(command, args, {
-      shell: true,
-      stdio: 'pipe',
-      ...options,
-    });
-    processReference.process = startedProcess;
-
-    let lastFormatting = '';
-    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);
-    });
-
-    this.managedProcesses.add(startedProcess);
-
-    startedProcess.on('error', (err) => {
-      console.error(
-        `[ProcessManager] Error starting managed process '${command}': ${err.message}`,
-      );
-      this.managedProcesses.delete(startedProcess);
-    });
-
-    startedProcess.on('exit', (code) => {
-      if (!this.managedProcesses.has(startedProcess)) {
-        return;
-      }
-
-      this.managedProcesses.delete(startedProcess);
-      if (this.cleanupInProgress) {
-        console.log(
-          `[ProcessManager] Managed process '${command}' (PID: ${startedProcess.pid}) exited due to cleanup.`,
-        );
-        return;
-      }
-
-      if (code !== 0) {
-        console.error(
-          `[ProcessManager] Managed process '${command}' (PID: ${startedProcess.pid}) exited with code ${code}.`,
-        );
-        if (restartOnError) {
-          console.warn(
-            `[ProcessManager] Restarting managed process '${command}'...`,
-          );
-          this.startManagedProcess(command, args, options, prefix, restartOnError, onExit, processReference);
-        } else {
-          onExit?.();
-        }
-      } else {
-        console.log(
-          `[ProcessManager] Managed process '${command}' (PID: ${startedProcess.pid}) exited cleanly.`,
-        );
-        onExit?.();
-      }
-    });
-
-    return processReference;
-  }
-
-  killProcess(process) {
-    if (process.killed || process.exitCode != null) {
-      return;
-    }
-
-    this.managedProcesses.delete(process);
-
-    return new Promise((resolve, reject) => {
-      let exited = false;
-      const onExit = () => {
-        exited = true;
-        resolve();
-      };
-      process.on('exit', onExit);
-
-      setTimeout(() => {
-        if (exited) {
-          return;
-        }
-
-        console.error(`[ProcessManager] Timeout reached for process interruption ${process.pid}`);
-        try {
-          process.kill('SIGKILL');
-        } catch (e) {
-          console.error(`[ProcessManager] Error force killing process ${process.pid}: ${e.message}`);
-          reject(e);
-        }
-      }, 500);
-
-      try {
-        process.kill('SIGTERM');
-        return;
-      } catch (e) {
-        console.error(`[ProcessManager] Error signaling process ${process.pid}: ${e.message}`);
-      }
-
-      try {
-        process.kill('SIGKILL');
-      } catch (e) {
-        console.error(`[ProcessManager] Error force killing process ${process.pid}: ${e.message}`);
-        reject(e);
-      }
-    });
-  }
-
-  /**
-   * Kills all currently managed child processes.
-   */
-  async cleanupManagedProcesses() {
-    if (this.cleanupInProgress) {
-      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]) {
-      if (proc.killed || proc.exitCode != null) {
-        continue;
-      }
-
-      console.log(`[ProcessManager] Killing managed process PID: ${proc.pid}`);
-      try {
-        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;
-      }
-
-      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.log('[ProcessManager] Managed process cleanup complete.');
-  }
-}
-
+const { spawn, spawnSync, execSync } = require('child_process');
+const log = require('./logger');
+const prefixLines = require("./prefix-lines");
+
+const isWindows = process.platform === 'win32';
+
+class ProcessManager {
+  constructor() {
+    this.managedProcesses = new Set();
+    this.cleanupInProgress = false;
+  }
+
+  /**
+   * Runs a command synchronously (blocking).
+   * Used for pre-commands, status checks, getting container names.
+   * @param {string} command - The command to execute.
+   * @param {string[]} args - Arguments for the command.
+   * @param {object} [options={}] - Options for spawnSync (e.g., cwd, stdio).
+   * @returns {string} The stdout of the command, trimmed.
+   * @throws {Error} If the command fails.
+   */
+  runSync(command, args = [], options = {}) {
+    if (this.cleanupInProgress) {
+      log.warn(`[ProcessManager] Skipping synchronous command '${command}' during cleanup.`);
+      return '';
+    }
+    log.debug(`[ProcessManager] Running sync: ${command} ${args.join(' ')}`);
+    try {
+      const result = spawnSync(command, args, {
+        shell: true,
+        encoding: 'utf8',
+        ...options,
+      });
+
+      if (result.error) {
+        throw result.error;
+      }
+      if (result.status !== 0) {
+        const stderrOutput = result.stderr ? result.stderr.trim() : 'No stderr output.';
+        throw new Error(
+          `Command failed with code ${result.status}: ${command} ${args.join(
+            ' ',
+          )}\n${stderrOutput}`,
+        );
+      }
+      return result.stdout?.trim() ?? '';
+    } catch (error) {
+      throw new Error(`Failed to run sync command '${command}': ${error.message}`);
+    }
+  }
+
+  /**
+   * Runs a command asynchronously, inheriting stdio.
+   * Used for initial 'docker compose up -d' where we want to see immediate output
+   * and the process is not meant to be continually managed/restarted by the orchestrator.
+   * @param {string} command - The command to execute.
+   * @param {string[]} args - Arguments for the command.
+   * @param {object} [options={}] - Options for spawn.
+   * @returns {Promise<void>} A promise that resolves when the process exits successfully.
+   */
+  runInherited(command, args = [], options = {}) {
+    return new Promise((resolve, reject) => {
+      if (this.cleanupInProgress) {
+        log.warn(`[ProcessManager] Skipping inherited command '${command}' during cleanup.`);
+        return resolve();
+      }
+      log.debug(`[ProcessManager] Running inherited: ${command} ${args.join(' ')}`);
+      const proc = spawn(command, args, {
+        shell: true,
+        stdio: 'inherit',
+        ...options,
+      });
+
+      proc.on('error', (err) => {
+        log.error(`[ProcessManager] Failed to start inherited command '${command}':`, err);
+        reject(err);
+      });
+
+      proc.on('exit', (code) => {
+        if (code !== 0) {
+          reject(
+            new Error(`Inherited command '${command}' exited with code ${code}`),
+          );
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  /**
+   * Starts a long-running, managed process (like 'npx rollup -w').
+   * Its output is prefixed, and it can be configured to restart on exit.
+   * @param {string} command - The command to execute.
+   * @param {string[]} args - Arguments for the command.
+   * @param {object} options - Options for spawn (e.g., cwd).
+   * @param {string} prefix - Prefix for stdout/stderr lines (e.g., 'frontend:').
+   * @param {boolean} restartOnError - Whether to restart the process if it exits with non-zero code.
+   * @param {Function} onExit
+   * @param {ChildProcess[] | undefined} processReference - An array where to save the process to gain a reference to it.
+   * @returns {ChildProcess} The spawned child process instance.
+   */
+  startManagedProcess(command, args, options, prefix, restartOnError, onExit, processReference) {
+    if (this.cleanupInProgress) {
+      log.warn(`[ProcessManager] Skipping managed process '${command}' during cleanup.`);
+      return null;
+    }
+    log.debug(
+      `[ProcessManager] Starting managed process: ${command} ${args.join(
+        ' ',
+      )} (prefix: ${prefix})`,
+    );
+
+    if (processReference == null) {
+      processReference = {}
+    }
+
+    const startedProcess = spawn(command, args, {
+      shell: true,
+      stdio: 'pipe',
+      ...options,
+      env: { FORCE_COLOR: '1', ...process.env, ...(options.env ?? {}) },
+    });
+    processReference.process = startedProcess;
+
+    let lastFormatting = '';
+    startedProcess.stdout.on('data', (data) => {
+      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, lastFormatting);
+      lastFormatting = result.lastFormatting;
+      process.stderr.write(result.prefixedText);
+    });
+
+    this.managedProcesses.add(startedProcess);
+
+    startedProcess.on('error', (err) => {
+      log.error(
+        `[ProcessManager] Error starting managed process '${command}': ${err.message}`,
+      );
+      this.managedProcesses.delete(startedProcess);
+    });
+
+    startedProcess.on('exit', (code) => {
+      if (!this.managedProcesses.has(startedProcess)) {
+        return;
+      }
+
+      this.managedProcesses.delete(startedProcess);
+      if (this.cleanupInProgress) {
+        log.debug(
+          `[ProcessManager] Managed process '${command}' (PID: ${startedProcess.pid}) exited due to cleanup.`,
+        );
+        return;
+      }
+
+      if (code !== 0) {
+        log.error(
+          `[ProcessManager] Managed process '${command}' (PID: ${startedProcess.pid}) exited with code ${code}.`,
+        );
+        if (restartOnError) {
+          log.warn(
+            `[ProcessManager] Restarting managed process '${command}'...`,
+          );
+          this.startManagedProcess(command, args, options, prefix, restartOnError, onExit, processReference);
+        } else {
+          onExit?.();
+        }
+      } else {
+        log.debug(
+          `[ProcessManager] Managed process '${command}' (PID: ${startedProcess.pid}) exited cleanly.`,
+        );
+        onExit?.();
+      }
+    });
+
+    return processReference;
+  }
+
+  /**
+   * 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(childProcess);
+
+    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();
+      };
+      childProcess.on('exit', onExit);
+
+      timeoutId = setTimeout(() => {
+        if (exited) {
+          return;
+        }
+
+        log.error(`[ProcessManager] Timeout reached for process interruption ${childProcess.pid}`);
+        try {
+          childProcess.kill('SIGKILL');
+        } catch (e) {
+          log.error(`[ProcessManager] Error force killing process ${childProcess.pid}: ${e.message}`);
+        }
+        resolve();
+      }, 500);
+
+      try {
+        childProcess.kill('SIGTERM');
+      } catch (e) {
+        log.error(`[ProcessManager] Error signaling process ${childProcess.pid}: ${e.message}`);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        resolve();
+      }
+    });
+  }
+
+  /**
+   * Kills all currently managed child processes.
+   */
+  async cleanupManagedProcesses() {
+    if (this.cleanupInProgress) {
+      log.debug('[ProcessManager] Cleanup of managed processes already in progress, skipping.');
+      return;
+    }
+
+    this.cleanupInProgress = true;
+
+    log.debug('\n[ProcessManager] Initiating cleanup of managed processes...');
+
+    // Filter out already-dead processes
+    const processesToKill = [...this.managedProcesses].filter(proc => {
+      if (proc.killed || proc.exitCode != null) {
+        this.managedProcesses.delete(proc);
+        return false;
+      }
+      return true;
+    });
+    
+    for (const proc of processesToKill) {
+      log.debug(`[ProcessManager] Killing managed process PID: ${proc.pid}`);
+      try {
+        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) {
+        log.error(`[ProcessManager] Error killing process ${proc.pid}: ${e.message}`);
+      }
+    }
+
+    // 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;
+        }
+
+        log.warn(`[ProcessManager] Process ${proc.pid} did not exit gracefully, forcing kill.`);
+        try {
+          proc.kill('SIGKILL');
+        } catch (e) {
+          log.error(`[ProcessManager] Error forcing kill for process ${proc.pid}: ${e.message}`);
+        }
+      }
+    }
+
+    log.debug('[ProcessManager] Managed process cleanup complete.');
+  }
+}
+
 module.exports = ProcessManager;

package/src/service-colors.js

@@ -0,0 +1,58 @@
+const PALETTE = [
+  91, 92, 93, 94, 95, 96, // bright red, green, yellow, blue, magenta, cyan
+  31, 32, 33, 34, 35, 36, // standard variants of the same
+];
+
+function shuffle(input) {
+  const arr = input.slice();
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+
+const shuffledPalette = shuffle(PALETTE);
+const colorByKey = new Map();
+
+function keyFor(name, mode, taskIndex) {
+  if (taskIndex == null) return `${name}\0${mode}`;
+  return `${name}\0${mode}\0${taskIndex}`;
+}
+
+function colorForKey(key) {
+  let color = colorByKey.get(key);
+  if (color != null) return color;
+  color = shuffledPalette[colorByKey.size % shuffledPalette.length];
+  colorByKey.set(key, color);
+  return color;
+}
+
+function colorize(text, code) {
+  return `\x1b[${code}m${text}\x1b[0m`;
+}
+
+function buildColoredPrefix(name, mode, taskIndex) {
+  const color = colorForKey(keyFor(name, mode, taskIndex));
+  const taskSegment = taskIndex != null ? `${taskIndex}:` : '';
+  return colorize(`${name}:${mode}:${taskSegment}`, color);
+}
+
+function buildColoredTag(name, mode) {
+  return colorize(`${name}:${mode}`, colorForKey(keyFor(name, mode)));
+}
+
+function colorService(name, mode) {
+  return colorize(name, colorForKey(keyFor(name, mode)));
+}
+
+function colorMode(name, mode) {
+  return colorize(mode, colorForKey(keyFor(name, mode)));
+}
+
+module.exports = {
+  buildColoredPrefix,
+  buildColoredTag,
+  colorService,
+  colorMode,
+};