go-dev 0.5.0 → 0.7.0

package/src/run.js

@@ -0,0 +1,57 @@
+const Orchestrator = require('./orchestrator');
+const { parseCliArgs } = require('./cli-args');
+const { findConfigFile } = require('./config');
+const { resolvePreset } = require('./dependency-resolver');
+const { runInteractive } = require('./interactive');
+const log = require('./logger');
+
+/**
+ * Shared CLI entry flow, used by both `bin/go-dev` and `src/index.js`.
+ *
+ * Resolves a service selection — from a preset name, or interactively when no
+ * preset is given (or `--interactive` is set) — and hands it to the orchestrator.
+ *
+ * @param {string[]} argv - argv tail (already stripped of node + script path).
+ */
+async function run(argv) {
+  try {
+    const { presetName, configPath, logLevel, interactive, remaining } = parseCliArgs(argv);
+
+    const resolvedConfigPath = configPath ?? findConfigFile();
+    const orchestrator = new Orchestrator(resolvedConfigPath, { logLevel });
+
+    let selection;
+    if (interactive || !presetName) {
+      if (!presetName && !process.stdin.isTTY) {
+        console.error(
+          'Error: no preset given and no interactive terminal. ' +
+          'Specify a preset (go-dev <preset>) or run in a TTY to use the interactive selector.'
+        );
+        process.exit(1);
+      }
+
+      selection = await runInteractive(orchestrator.config, {
+        configPath: resolvedConfigPath,
+        presetName,
+      });
+      if (!selection) {
+        process.exit(0); // user cancelled
+      }
+    } else {
+      selection = { name: presetName, ...resolvePreset(orchestrator.config, presetName) };
+    }
+
+    // Keep `remaining` (the `--args-for ...` tail) at argv index >= 3, where the
+    // orchestrator's per-service args parser reads it. Index 2 is unused there.
+    process.argv = [process.argv[0], process.argv[1], selection.name ?? '', ...remaining];
+
+    await orchestrator.start(selection);
+  } catch (error) {
+    // Setup-phase failures (bad config, unknown preset, TUI errors). The
+    // orchestrator handles its own runtime errors and cleanup internally.
+    log.error(`\n❌ ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { run };

package/src/save-preset.js

@@ -0,0 +1,103 @@
+const fs = require('fs');
+const yaml = require('js-yaml');
+const { loadConfig } = require('./config');
+
+/**
+ * Renders a value as a YAML scalar, quoting it only when it isn't a plain,
+ * safe identifier. Service/mode names come from config keys (already safe);
+ * user-typed preset names may need quoting.
+ */
+function scalar(value) {
+  return /^[A-Za-z0-9_][A-Za-z0-9_.-]*$/.test(value) ? value : JSON.stringify(value);
+}
+
+/**
+ * Builds the YAML block for a single preset entry, indented under `presets:`.
+ *
+ * @param {string} name
+ * @param {{ services: string[], modes?: Record<string, string> }} selection
+ * @param {string} indent - leading indentation for the entry key (e.g. '  ').
+ */
+function buildPresetBlock(name, selection, indent) {
+  const step = '  ';
+  const lines = [
+    `${indent}${scalar(name)}:`,
+    `${indent}${step}services: [${selection.services.map(scalar).join(', ')}]`,
+  ];
+
+  const modes = selection.modes ?? {};
+  const modeEntries = Object.entries(modes).filter(([, mode]) => mode != null);
+  if (modeEntries.length > 0) {
+    lines.push(`${indent}${step}modes:`);
+    for (const [service, mode] of modeEntries) {
+      lines.push(`${indent}${step}${step}${scalar(service)}: ${scalar(mode)}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Inserts a preset into a raw YAML config, preserving the rest of the file
+ * (comments, key order, formatting). Falls back to a full re-dump only when the
+ * existing `presets:` key isn't a plain block we can append to.
+ *
+ * @param {string} raw
+ * @param {string} name
+ * @param {object} selection
+ * @returns {string} the new file content
+ */
+function insertPreset(raw, name, selection) {
+  const lines = raw.split('\n');
+  const presetsIndex = lines.findIndex((line) => /^(\s*)presets:\s*$/.test(line));
+
+  // Case A: a plain `presets:` block key exists — insert as its first entry.
+  if (presetsIndex >= 0) {
+    const baseIndent = lines[presetsIndex].match(/^(\s*)/)[1] + '  ';
+    const block = buildPresetBlock(name, selection, baseIndent);
+    lines.splice(presetsIndex + 1, 0, block);
+    return lines.join('\n');
+  }
+
+  // Case B: no `presets:` key at all — append a fresh block at the end.
+  const hasPresetsKey = lines.some((line) => /^\s*presets:/.test(line));
+  if (!hasPresetsKey) {
+    const trimmed = raw.replace(/\s*$/, '');
+    const block = buildPresetBlock(name, selection, '  ');
+    return `${trimmed}\n\npresets:\n${block}\n`;
+  }
+
+  // Case C: `presets:` exists but inline (e.g. `presets: {}`) — re-dump to stay
+  // structurally correct. Comments are lost; acceptable for this edge case.
+  const parsed = yaml.load(raw) ?? {};
+  parsed.presets = parsed.presets ?? {};
+  parsed.presets[name] = {
+    services: selection.services,
+    ...(Object.keys(selection.modes ?? {}).length > 0 ? { modes: selection.modes } : {}),
+  };
+  return yaml.dump(parsed, { lineWidth: 120 });
+}
+
+/**
+ * Persists a selection as a named preset in the given config file, then
+ * re-validates the file by loading it. On validation failure the original
+ * content is restored and the error is re-thrown.
+ *
+ * @param {string} configPath
+ * @param {string} name
+ * @param {{ services: string[], modes?: Record<string, string> }} selection
+ */
+function savePreset(configPath, name, selection) {
+  const original = fs.readFileSync(configPath, 'utf8');
+  const updated = insertPreset(original, name, selection);
+
+  fs.writeFileSync(configPath, updated, 'utf8');
+  try {
+    loadConfig(configPath);
+  } catch (error) {
+    fs.writeFileSync(configPath, original, 'utf8');
+    throw new Error(`Failed to save preset '${name}': ${error.message}`);
+  }
+}
+
+module.exports = { savePreset, insertPreset };

package/src/services/cmd.js

@@ -1,6 +1,7 @@
 const log = require('../logger');
 const { BaseService } = require('./base');
 const { buildColoredPrefix, buildColoredTag } = require('../service-colors');
+const { waitForReady } = require('./ready-check');
 
 class CmdService extends BaseService {
   /**
@@ -70,9 +71,11 @@ class CmdService extends BaseService {
       }
 
       const normalized = CmdService._normalizeCommands(config.commands);
-      await Promise.all(normalized.map(({ command, directory }) => {
+      const useIndex = normalized.length > 1;
+      await Promise.all(normalized.map(({ command, directory }, index) => {
         const [cmd, ...args] = command;
-        return CmdService._processManager.runInherited(cmd, args, { cwd: directory });
+        const prefix = buildColoredPrefix(serviceName, mode, useIndex ? index : null);
+        return CmdService._processManager.runInheritedPrefixed(cmd, args, { cwd: directory }, prefix);
       }));
 
       log.info(`[${ctx}] preCommand service completed.`);
@@ -98,10 +101,12 @@ class CmdService extends BaseService {
       ? { cmdArgs: pre }
       : { cmdArgs: pre.command, directory: pre.directory });
     try {
-      CmdService._processManager.runSync(cmdArgs[0], cmdArgs.slice(1), {
-        cwd: directory,
-        stdio: 'inherit',
-      });
+      await CmdService._processManager.runInheritedPrefixed(
+        cmdArgs[0],
+        cmdArgs.slice(1),
+        { cwd: directory },
+        fromContext,
+      );
     } catch (error) {
       log.debug({ cmdArgs });
       throw new Error(
@@ -222,6 +227,14 @@ class CmdService extends BaseService {
         `[${this.coloredId}] Process started (PID: ${process.process.pid}).`,
       );
     }
+
+    if (this.config.readyWhen) {
+      await waitForReady(
+        this.processes.map(({ process }) => process),
+        this.config.readyWhen,
+        this.coloredId,
+      );
+    }
   }
 
   async stop() {

package/src/services/ready-check.js

@@ -0,0 +1,134 @@
+const net = require('net');
+const fs = require('fs');
+const path = require('path');
+const log = require('../logger');
+
+const MAX_BUFFER = 16 * 1024;
+
+/**
+ * Resolves when one of the managed processes prints a line matching `pattern`.
+ * Attaches an extra listener on top of the existing prefixing one, so it does
+ * not interfere with normal output.
+ */
+function logMatchCheck(processes, pattern, timeoutMs) {
+  const regex = new RegExp(pattern);
+  let cleanup = () => {};
+  const promise = new Promise((resolve, reject) => {
+    let buffer = '';
+    const listeners = [];
+    const onData = (data) => {
+      buffer = (buffer + data.toString()).slice(-MAX_BUFFER);
+      if (regex.test(buffer)) {
+        resolve();
+      }
+    };
+    for (const proc of processes) {
+      for (const stream of [proc.stdout, proc.stderr]) {
+        if (!stream) {
+          continue;
+        }
+        stream.on('data', onData);
+        listeners.push(stream);
+      }
+    }
+    const timer = setTimeout(() => {
+      reject(new Error(`Timed out after ${timeoutMs}ms waiting for log /${pattern}/`));
+    }, timeoutMs);
+    cleanup = () => {
+      clearTimeout(timer);
+      for (const stream of listeners) {
+        stream.off('data', onData);
+      }
+    };
+  });
+  return { promise: promise.finally(() => cleanup()), cancel: () => cleanup() };
+}
+
+/** Resolves once `filePath` exists on disk, polling until the timeout. */
+function fileCheck(filePath, timeoutMs, pollIntervalMs) {
+  const resolved = path.resolve(filePath);
+  let cancelled = false;
+  const promise = (async () => {
+    const deadline = Date.now() + timeoutMs;
+    while (!cancelled) {
+      if (fs.existsSync(resolved)) {
+        return;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out after ${timeoutMs}ms waiting for file '${resolved}'`);
+      }
+      await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+    }
+  })();
+  return { promise, cancel: () => { cancelled = true; } };
+}
+
+function tryConnect(host, port) {
+  return new Promise((resolve) => {
+    const socket = net.connect({ host, port });
+    const done = (ok) => {
+      socket.destroy();
+      resolve(ok);
+    };
+    socket.once('connect', () => done(true));
+    socket.once('error', () => done(false));
+    socket.setTimeout(1000, () => done(false));
+  });
+}
+
+/** Resolves once a TCP connection to `host:port` succeeds, polling until the timeout. */
+function portCheck(host, port, timeoutMs, pollIntervalMs) {
+  let cancelled = false;
+  const promise = (async () => {
+    const deadline = Date.now() + timeoutMs;
+    while (!cancelled) {
+      if (await tryConnect(host, port)) {
+        return;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out after ${timeoutMs}ms waiting for ${host}:${port}`);
+      }
+      await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+    }
+  })();
+  return { promise, cancel: () => { cancelled = true; } };
+}
+
+/**
+ * Blocks until the given `readyWhen` conditions are all satisfied for the
+ * provided managed processes. Multiple conditions are combined with AND.
+ * @param {import('child_process').ChildProcess[]} processes
+ * @param {object} readyWhen - Validated `readyWhen` config (with defaults applied).
+ * @param {string} coloredId - The service's colored tag, for logging.
+ */
+async function waitForReady(processes, readyWhen, coloredId) {
+  const { logMatch, file, port, host, timeoutMs, pollIntervalMs } = readyWhen;
+
+  const checks = [];
+  const labels = [];
+  if (logMatch != null) {
+    checks.push(logMatchCheck(processes, logMatch, timeoutMs));
+    labels.push(`log /${logMatch}/`);
+  }
+  if (file != null) {
+    checks.push(fileCheck(file, timeoutMs, pollIntervalMs));
+    labels.push(`file '${file}'`);
+  }
+  if (port != null) {
+    checks.push(portCheck(host, port, timeoutMs, pollIntervalMs));
+    labels.push(`${host}:${port}`);
+  }
+
+  log.info(`[${coloredId}] Waiting until ready (${labels.join(' AND ')})...`);
+  try {
+    await Promise.all(checks.map(check => check.promise));
+    log.info(`[${coloredId}] Service is ready.`);
+  } finally {
+    // Stop any still-pending checks so they don't reject after we're done.
+    for (const check of checks) {
+      check.cancel();
+    }
+  }
+}
+
+module.exports = { waitForReady };