go-dev 0.4.2 → 0.5.0

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,
+};

package/src/services/base.js

@@ -1,52 +1,64 @@
-class BaseService {
-  /** @type {import("../process-manager")} */
-  static _processManager = null;
-
-  /**
-   * Initializes the shared ProcessManager for all service types.
-   * This should be called once at application startup.
-   * @param {import("../process-manager")} processManagerInstance
-   */
-  static initialize(processManagerInstance) {
-    if (BaseService._processManager) {
-      console.warn('BaseService.initialize called multiple times. Skipping.');
-      return;
-    }
-    BaseService._processManager = processManagerInstance;
-  }
-
-  /**
-   * Static method for type-specific cleanup. To be overridden by subclasses.
-   * @returns {Promise<void>}
-   */
-  static async cleanup() {
-    console.log(`[${this.name}] No specific static cleanup defined.`);
-  }
-
-  /**
-   * @param {string} name - The logical name of the service (e.g., 'api', 'frontend').
-   * @param {string} mode - The resolved mode for this service (e.g., 'dev', 'docker', 'serve').
-   * @param {object} config - The concrete configuration object for this service and mode.
-   */
-  constructor(name, mode, config, onExit, extraArgs) {
-    this.name = name;
-    this.mode = mode;
-    this.config = config;
-    this.onExit = onExit;
-    this.extraArgs = extraArgs;
-  }
-
-  async start() {
-    throw new Error(`Service type for '${this.name}' in mode '${this.mode}' must implement start()`);
-  }
-
-  async stop() {
-    return;
-  }
-
-  async checkHealth() {
-    return true;
-  }
-}
-
+const log = require('../logger');
+const { buildColoredTag } = require('../service-colors');
+
+class BaseService {
+  /** @type {import("../process-manager")} */
+  static _processManager = null;
+
+  /** @type {object | null} */
+  static _servicesMap = null;
+
+  /**
+   * Initializes shared state for all service types.
+   * This should be called once at application startup.
+   * @param {import("../process-manager")} processManagerInstance
+   * @param {object} [servicesMap] - The full `services` block from the loaded config, keyed by service name.
+   */
+  static initialize(processManagerInstance, servicesMap) {
+    if (BaseService._processManager) {
+      log.warn('BaseService.initialize called multiple times. Skipping.');
+      return;
+    }
+    BaseService._processManager = processManagerInstance;
+    BaseService._servicesMap = servicesMap ?? null;
+  }
+
+  /**
+   * Static method for type-specific cleanup. To be overridden by subclasses.
+   * @returns {Promise<void>}
+   */
+  static async cleanup() {
+    log.debug(`[${this.name}] No specific static cleanup defined.`);
+  }
+
+  /**
+   * @param {string} name - The logical name of the service (e.g., 'api', 'frontend').
+   * @param {string} mode - The resolved mode for this service (e.g., 'dev', 'docker', 'serve').
+   * @param {object} config - The concrete configuration object for this service and mode.
+   */
+  constructor(name, mode, config, onExit, extraArgs) {
+    this.name = name;
+    this.mode = mode;
+    this.config = config;
+    this.onExit = onExit;
+    this.extraArgs = extraArgs;
+  }
+
+  get coloredId() {
+    return buildColoredTag(this.name, this.mode);
+  }
+
+  async start() {
+    throw new Error(`Service type for '${this.name}' in mode '${this.mode}' must implement start()`);
+  }
+
+  async stop() {
+    return;
+  }
+
+  async checkHealth() {
+    return true;
+  }
+}
+
 module.exports = { BaseService };

package/src/services/cmd.js

@@ -1,149 +1,238 @@
-const { BaseService } = require('./base');
-
-class CmdService extends BaseService {
-  constructor(name, mode, config, onExit, extraArgs) {
-    super(name, mode, config, onExit, extraArgs);
-    this.prefix = `${name}:${mode}:`;
-    this.processes = [];
-  }
-
-  async start() {
-    console.log(`[${this.name}:${this.mode}] Starting cmd service...`);
-
-    const { preCommands, commands } = this.config;
-    if (!commands) {
-      throw new Error(
-        `[${this.name}:${this.mode}] Commands not found for service.`,
-      );
-    }
-
-    if (preCommands && preCommands.length > 0) {
-      console.log(`[${this.name}:${this.mode}] Running pre-commands...`);
-      for (const command of preCommands) {
-        const { cmdArgs, directory } = (Array.isArray(command) ?
-          { cmdArgs: command } :
-          { cmdArgs: command.command, directory: command.directory }
-        );
-        try {
-          CmdService._processManager.runSync(cmdArgs[0], cmdArgs.slice(1), {
-            cwd: directory,
-            stdio: 'inherit',
-          });
-        } catch (error) {
-          console.log({ cmdArgs });
-          throw new Error(
-            `[${this.name}:${this.mode}] Pre-command failed: ${cmdArgs.join(
-              ' ',
-            )}: ${error.message}`,
-          );
-        }
-      }
-      console.log(`[${this.name}:${this.mode}] Pre-commands completed.`);
-    }
-
-    const { cmdArgs, directory, restartOnError } = (Array.isArray(commands) && typeof commands[0] === 'string' ?
-      { cmdArgs: [commands], directory: [undefined], restartOnError: [undefined] } :
-      (Array.isArray(commands) ?
-        {
-          cmdArgs: commands.map(({ command }) => command),
-          directory: commands.map(({ directory }) => directory),
-          restartOnError: commands.map(({ restartOnError }) => restartOnError),
-        } :
-        {
-          cmdArgs: [commands.command],
-          directory: [commands.directory],
-          restartOnError: [commands.restartOnError],
-        }
-      )
-    );
-
-    const useProcessIndex = cmdArgs.length > 1;
-    const exitedProcess = Array.from({ length: cmdArgs.length });
-    for (let index = 0; index < cmdArgs.length; index++) {
-      const [command, ...args] = cmdArgs[index];
-
-      const extraArgs = (this.extraArgs?.[index] ?? []).slice();
-
-      const finalArgs = args.map(arg => {
-        const regex = /(\\*)\$arg/g;
-
-        let indexesToReplace = [];
-        while (true) {
-          const match = regex.exec(arg);
-          if (match == null) {
-            break;
-          }
-
-          const backslashes = match[1];
-
-          const startIndex = match.index + backslashes.length;
-
-          if (backslashes.length % 2 === 1) {
-            indexesToReplace.unshift({
-              startIndex: startIndex - 1,
-              endIndex: startIndex + 5,
-              replacement: '$arg',
-            });
-            continue;
-          }
-
-          const replacement = extraArgs.shift() ?? '';
-          indexesToReplace.unshift({
-            startIndex,
-            endIndex: startIndex + 4,
-            replacement,
-          });
-        }
-
-        indexesToReplace.forEach(({ startIndex, endIndex, replacement }) => {
-          console.log({ replacement, start: arg.slice(0, startIndex) });
-          arg = arg.slice(0, startIndex) + replacement + arg.slice(endIndex);
-        });
-
-        return arg;
-      }).concat(extraArgs);
-
-      const process = CmdService._processManager.startManagedProcess(
-        command,
-        finalArgs,
-        { cwd: directory[index] },
-        (useProcessIndex ?
-          `${this.prefix}${index}:` :
-          this.prefix
-        ),
-        restartOnError[index],
-        () => {
-          exitedProcess[index] = true;
-          if (exitedProcess.some(exited => !exited)) {
-            return;
-          }
-
-          this.onExit?.();
-        }
-      );
-  
-      if (!process) {
-        throw new Error(
-          `[${this.name}:${this.mode}] Failed to spawn process: ${command.join(' ')}`,
-        );
-      }
-
-      this.processes.push(process);
-      console.log(
-        `[${this.name}:${this.mode}] Process started (PID: ${process.process.pid}).`,
-      );
-    }
-  }
-
-  async stop() {
-    const promises = this.processes.map(({ process }) => {
-      console.log(`[${this.name}:${this.mode}] Stopping process (PID: ${process.pid}).`);
-      return CmdService._processManager.killProcess(process);
-    });
-    this.processes.splice(0, this.processes.length);
-
-    await Promise.all(promises);
-  }
-}
-
+const log = require('../logger');
+const { BaseService } = require('./base');
+const { buildColoredPrefix, buildColoredTag } = require('../service-colors');
+
+class CmdService extends BaseService {
+  /**
+   * Per-process cache of in-flight or completed service-as-preCommand runs.
+   * Key: `${serviceName}:${resolvedMode}`. Value: Promise<void> for the run.
+   */
+  static _serviceCommandCache = new Map();
+
+  constructor(name, mode, config, onExit, extraArgs) {
+    super(name, mode, config, onExit, extraArgs);
+    this.processes = [];
+  }
+
+  static _normalizeCommands(commands) {
+    if (Array.isArray(commands) && typeof commands[0] === 'string') {
+      return [{ command: commands, directory: undefined }];
+    }
+    if (Array.isArray(commands)) {
+      return commands.map(c => (Array.isArray(c)
+        ? { command: c, directory: undefined }
+        : { command: c.command, directory: c.directory }
+      ));
+    }
+    return [{ command: commands.command, directory: commands.directory }];
+  }
+
+  static _resolveServiceMode(serviceName, requestedMode) {
+    const allServices = BaseService._servicesMap;
+    const service = allServices?.[serviceName];
+    if (!service) {
+      throw new Error(`Service '${serviceName}' referenced as preCommand not found in configuration.`);
+    }
+    const mode = (service.type === 'hybrid'
+      ? requestedMode ?? service.defaultMode ?? 'dev'
+      : requestedMode ?? 'dev');
+    const config = (service.type === 'hybrid'
+      ? service.modes?.[mode]
+      : (mode === 'dev' ? service : undefined));
+    if (config == null) {
+      throw new Error(`Mode '${mode}' not found in service '${serviceName}'.`);
+    }
+    if (config.type !== 'cmd') {
+      throw new Error(
+        `preCommand service '${serviceName}:${mode}' must be of type 'cmd', got '${config.type}'.`,
+      );
+    }
+    return { mode, config };
+  }
+
+  static _runServiceAsPreCommand(serviceName, requestedMode, fromContext) {
+    const { mode, config } = CmdService._resolveServiceMode(serviceName, requestedMode);
+    const key = `${serviceName}:${mode}`;
+    const existing = CmdService._serviceCommandCache.get(key);
+    if (existing) {
+      log.info(`[${fromContext}] preCommand service '${key}' already in flight or completed; awaiting.`);
+      return existing;
+    }
+
+    const promise = (async () => {
+      const ctx = buildColoredTag(serviceName, mode);
+      log.info(`[${ctx}] Running as preCommand service...`);
+
+      if (config.preCommands && config.preCommands.length > 0) {
+        for (const pre of config.preCommands) {
+          await CmdService._runPreCommand(pre, ctx);
+        }
+      }
+
+      const normalized = CmdService._normalizeCommands(config.commands);
+      await Promise.all(normalized.map(({ command, directory }) => {
+        const [cmd, ...args] = command;
+        return CmdService._processManager.runInherited(cmd, args, { cwd: directory });
+      }));
+
+      log.info(`[${ctx}] preCommand service completed.`);
+    })();
+
+    CmdService._serviceCommandCache.set(key, promise);
+    return promise;
+  }
+
+  static async _runPreCommand(pre, fromContext) {
+    if (!Array.isArray(pre) && pre != null && typeof pre === 'object' && pre.service != null) {
+      try {
+        await CmdService._runServiceAsPreCommand(pre.service, pre.mode, fromContext);
+      } catch (error) {
+        throw new Error(
+          `[${fromContext}] Pre-command service '${pre.service}${pre.mode ? `:${pre.mode}` : ''}' failed: ${error.message}`,
+        );
+      }
+      return;
+    }
+
+    const { cmdArgs, directory } = (Array.isArray(pre)
+      ? { cmdArgs: pre }
+      : { cmdArgs: pre.command, directory: pre.directory });
+    try {
+      CmdService._processManager.runSync(cmdArgs[0], cmdArgs.slice(1), {
+        cwd: directory,
+        stdio: 'inherit',
+      });
+    } catch (error) {
+      log.debug({ cmdArgs });
+      throw new Error(
+        `[${fromContext}] Pre-command failed: ${cmdArgs.join(' ')}: ${error.message}`,
+      );
+    }
+  }
+
+  async start() {
+    log.info(`[${this.coloredId}] Starting cmd service...`);
+
+    const { preCommands, commands } = this.config;
+    if (!commands) {
+      throw new Error(
+        `[${this.coloredId}] Commands not found for service.`,
+      );
+    }
+
+    if (preCommands && preCommands.length > 0) {
+      log.info(`[${this.coloredId}] Running pre-commands...`);
+      for (const pre of preCommands) {
+        await CmdService._runPreCommand(pre, this.coloredId);
+      }
+      log.info(`[${this.coloredId}] Pre-commands completed.`);
+    }
+
+    const { cmdArgs, directory, restartOnError } = (Array.isArray(commands) && typeof commands[0] === 'string' ?
+      { cmdArgs: [commands], directory: [undefined], restartOnError: [undefined] } :
+      (Array.isArray(commands) ?
+        {
+          cmdArgs: commands.map(({ command }) => command),
+          directory: commands.map(({ directory }) => directory),
+          restartOnError: commands.map(({ restartOnError }) => restartOnError),
+        } :
+        {
+          cmdArgs: [commands.command],
+          directory: [commands.directory],
+          restartOnError: [commands.restartOnError],
+        }
+      )
+    );
+
+    const useProcessIndex = cmdArgs.length > 1;
+    const exitedProcess = Array.from({ length: cmdArgs.length });
+    for (let index = 0; index < cmdArgs.length; index++) {
+      const [command, ...args] = cmdArgs[index];
+
+      const extraArgs = (this.extraArgs?.[index] ?? []).slice();
+
+      const finalArgs = args.map(arg => {
+        const regex = /(\\*)\$arg/g;
+
+        let indexesToReplace = [];
+        while (true) {
+          const match = regex.exec(arg);
+          if (match == null) {
+            break;
+          }
+
+          const backslashes = match[1];
+
+          const startIndex = match.index + backslashes.length;
+
+          if (backslashes.length % 2 === 1) {
+            indexesToReplace.unshift({
+              startIndex: startIndex - 1,
+              endIndex: startIndex + 5,
+              replacement: '$arg',
+            });
+            continue;
+          }
+
+          const replacement = extraArgs.shift() ?? '';
+          indexesToReplace.unshift({
+            startIndex,
+            endIndex: startIndex + 4,
+            replacement,
+          });
+        }
+
+        indexesToReplace.forEach(({ startIndex, endIndex, replacement }) => {
+          log.debug({ replacement, start: arg.slice(0, startIndex) });
+          arg = arg.slice(0, startIndex) + replacement + arg.slice(endIndex);
+        });
+
+        return arg;
+      }).concat(extraArgs);
+
+      const prefix = buildColoredPrefix(
+        this.name,
+        this.mode,
+        useProcessIndex ? index : null,
+      );
+      const process = CmdService._processManager.startManagedProcess(
+        command,
+        finalArgs,
+        { cwd: directory[index] },
+        prefix,
+        restartOnError[index],
+        () => {
+          exitedProcess[index] = true;
+          if (exitedProcess.some(exited => !exited)) {
+            return;
+          }
+
+          this.onExit?.();
+        }
+      );
+  
+      if (!process) {
+        throw new Error(
+          `[${this.coloredId}] Failed to spawn process: ${command.join(' ')}`,
+        );
+      }
+
+      this.processes.push(process);
+      log.debug(
+        `[${this.coloredId}] Process started (PID: ${process.process.pid}).`,
+      );
+    }
+  }
+
+  async stop() {
+    const promises = this.processes.map(({ process }) => {
+      log.debug(`[${this.coloredId}] Stopping process (PID: ${process.pid}).`);
+      return CmdService._processManager.killProcess(process);
+    });
+    this.processes.splice(0, this.processes.length);
+
+    await Promise.all(promises);
+  }
+}
+
 module.exports = { CmdService };