go-dev 0.5.0 → 0.7.0

package/src/cli-args.js

@@ -5,18 +5,20 @@
  *   <preset>                                   — positional preset name (first non-flag arg)
  *   -c <path>,  --config <path>,  -c=<path>,    --config=<path>
  *   -l <level>, --log-level <level>, -l=<lvl>,  --log-level=<lvl>
+ *   -i,         --interactive                   — force the interactive TUI even when a preset is given
  *
  * Flags are only interpreted before the first `--args-for` token. Everything
  * from `--args-for` onward is preserved verbatim in `remaining` so the
  * orchestrator's per-service args parser can consume it untouched.
  *
  * @param {string[]} argv - argv tail (already stripped of node + script path).
- * @returns {{ presetName?: string, configPath?: string, logLevel?: string, remaining: string[] }}
+ * @returns {{ presetName?: string, configPath?: string, logLevel?: string, interactive: boolean, remaining: string[] }}
  */
 function parseCliArgs(argv) {
   let presetName;
   let configPath;
   let logLevel;
+  let interactive = false;
   const remaining = [];
 
   let i = 0;
@@ -65,6 +67,11 @@ function parseCliArgs(argv) {
       continue;
     }
 
+    if (arg === '-i' || arg === '--interactive') {
+      interactive = true;
+      continue;
+    }
+
     if (presetName == null && !arg.startsWith('-')) {
       presetName = arg;
       continue;
@@ -77,7 +84,7 @@ function parseCliArgs(argv) {
     remaining.push(argv[i]);
   }
 
-  return { presetName, configPath, logLevel, remaining };
+  return { presetName, configPath, logLevel, interactive, remaining };
 }
 
 module.exports = { parseCliArgs };

package/src/config.js

@@ -31,6 +31,15 @@ const preCommandConfigSchema = Joi.alternatives().try(
     serviceRefSchema,
 );
 
+const readyWhenSchema = Joi.object({
+  logMatch: Joi.string().min(1),
+  file: Joi.string().min(1),
+  port: Joi.number().integer().min(1).max(65535),
+  host: Joi.string().min(1).default('127.0.0.1'),
+  timeoutMs: Joi.number().integer().min(0).default(60000),
+  pollIntervalMs: Joi.number().integer().min(50).default(500),
+}).or('logMatch', 'file', 'port');
+
 const cmdServiceConfigSchema = Joi.object({
   type: Joi.string().valid('cmd').required(),
   preCommands: Joi.array().items(preCommandConfigSchema).default([]),
@@ -41,6 +50,7 @@ const cmdServiceConfigSchema = Joi.object({
   defaultCommand: Joi.string().default('start'),
   directory: Joi.string(),
   dependencies: Joi.array().items(dependencyEntrySchema).default([]),
+  readyWhen: readyWhenSchema.optional(),
   healthCheck: Joi.boolean().default(false)
 });
 
@@ -131,4 +141,4 @@ function loadConfig(configPath) {
   return value;
 }
 
-module.exports = { loadConfig };
+module.exports = { loadConfig, findConfigFile };

package/src/dependency-resolver.js

@@ -1,55 +1,72 @@
-const log = require('./logger');
-
-function resolveServiceExecutionGraph(config, presetName) {
+/**
+ * Resolves a named preset to its `{ services, modes }` selection object,
+ * throwing if it does not exist. This is the single place that maps a preset
+ * name to data — everything downstream operates on the selection object, so a
+ * preset is just one way (alongside the interactive TUI) to produce one.
+ *
+ * @param {object} config
+ * @param {string} presetName
+ * @returns {{ services: string[], modes: Record<string, string> }}
+ */
+function resolvePreset(config, presetName) {
   const preset = config.presets[presetName];
   if (!preset) {
     throw new Error(`Preset '${presetName}' not found in configuration.`);
   }
+  return preset;
+}
+
+/**
+ * @param {object} config
+ * @param {{ services: string[], modes?: Record<string, string> }} selection
+ *   A service selection — same shape as a preset. May come from a preset
+ *   (via {@link resolvePreset}) or be built interactively.
+ * @returns {{
+ *   services: { name: string, mode: string, config: object }[],
+ *   dependencies: { name: string, mode: string, config: object, requiredBy: string }[],
+ *   conflicts: { service: string, requests: { mode: string, by: string | null }[] }[]
+ * }} `conflicts` lists services pulled in under more than one mode (e.g. one as
+ *   a primary and another as a dependency). go-dev runs one instance per
+ *   service name, so a conflicting selection leaves some dependency unmet.
+ */
+function resolveServiceExecutionGraph(config, selection) {
+  const modes = selection.modes ?? {};
 
   const services = [];
   const dependencies = [];
+  // serviceName -> Map<mode, requestedBy|null> — every mode a service is asked
+  // to run in, regardless of which instance actually wins the dedup below.
+  const requests = new Map();
 
-  for (const serviceName of preset.services) {
+  for (const serviceName of selection.services) {
     addService(
       serviceName,
-      preset.modes[serviceName],
+      modes[serviceName],
       null,
     );
   }
 
-  return { dependencies, services };
+  const conflicts = [];
+  for (const [service, byMode] of requests) {
+    if (byMode.size > 1) {
+      conflicts.push({
+        service,
+        requests: [...byMode].map(([mode, by]) => ({ mode, by })),
+      });
+    }
+  }
+
+  return { dependencies, services, conflicts };
 
-  function addService(serviceName, mode, dependentService) {
+  function addService(serviceName, requestedMode, dependentService) {
     const service = config.services[serviceName];
     if (service == null) {
       throw new Error(`Service named '${serviceName}' not found in configuration.`);
     }
 
-    if (dependentService != null) {
-      const existingService = services.find(({ name }) => {
-        return name === serviceName;
-      });
-      if (existingService != null) {
-        log.warn(
-          `Ignoring dependency '${serviceName}' for '${dependentService}' because it is flagged to be run as service in mode '${existingService.mode}'.`
-        );
-        return;
-      }
-    } else {
-      const existingDependencyIndex = dependencies.findIndex(({ name }) => {
-        return name === serviceName;
-      });
-      if (existingDependencyIndex >= 0) {
-        log.warn(
-          `Removing service '${serviceName}' from dependencies because it is flagged to be run as service in mode '${dependencies[existingDependencyIndex].mode}'.`
-        );
-        dependencies.splice(existingDependencyIndex, 1);
-      }
-    }
-
-    mode = (service.type === 'hybrid' ?
-      mode ?? service.defaultMode ?? 'dev' :
-      mode ?? 'dev'
+    const mode = (service.type === 'hybrid' ?
+      requestedMode ?? service.defaultMode ?? 'dev' :
+      requestedMode ?? 'dev'
     );
     const serviceConfig = (service.type === 'hybrid' ?
       service.modes[mode] :
@@ -60,18 +77,29 @@ function resolveServiceExecutionGraph(config, presetName) {
       throw new Error(`Mode named '${mode}' not found in service '${serviceName}'.`);
     }
 
-    if (dependentService == null) {
-      services.push({
-        name: serviceName,
-        mode,
-        config: serviceConfig,
-      });
+    // Record the requested mode so conflicting selections can be flagged later,
+    // even for the instance that loses the dedup below.
+    let requested = requests.get(serviceName);
+    if (!requested) {
+      requests.set(serviceName, requested = new Map());
+    }
+    if (!requested.has(mode)) {
+      requested.set(mode, dependentService ?? null);
+    }
+
+    if (dependentService != null) {
+      // One instance per service name: if it's already scheduled (as a primary
+      // or another dependency), keep the first. Mode mismatches surface via
+      // `conflicts`, not by silently swapping the running mode.
+      if (services.some(({ name }) => name === serviceName)) return;
+      if (dependencies.some(({ name }) => name === serviceName)) return;
+      dependencies.unshift({ name: serviceName, mode, config: serviceConfig, requiredBy: dependentService });
     } else {
-      dependencies.unshift({
-        name: serviceName,
-        mode,
-        config: serviceConfig,
-      });
+      const existingDependencyIndex = dependencies.findIndex(({ name }) => name === serviceName);
+      if (existingDependencyIndex >= 0) {
+        dependencies.splice(existingDependencyIndex, 1); // promote dependency -> primary
+      }
+      services.push({ name: serviceName, mode, config: serviceConfig });
     }
 
     for (let index = serviceConfig.dependencies.length - 1; index >= 0; index--) {
@@ -84,14 +112,6 @@ function resolveServiceExecutionGraph(config, presetName) {
         dependency
       );
 
-      const existingDependencyIndex = dependencies.find(({ name }) => {
-        return name === dependencyName;
-      });
-      if (existingDependencyIndex != null) {
-        log.warn(`Skipping dependency '${dependencyName}' for '${serviceName}' because it's already present in dependencies list.`);
-        continue;
-      }
-
       addService(
         dependencyName,
         dependencyMode,
@@ -101,4 +121,4 @@ function resolveServiceExecutionGraph(config, presetName) {
   }
 }
 
-module.exports = { resolveServiceExecutionGraph };
+module.exports = { resolveServiceExecutionGraph, resolvePreset };

package/src/index.js

@@ -1,9 +1,5 @@
-const Orchestrator = require('./orchestrator');
-const { parseCliArgs } = require('./cli-args');
+const { run } = require('./run');
 
-const { presetName, configPath, logLevel, remaining } = parseCliArgs(process.argv.slice(2));
+run(process.argv.slice(2));
 
-process.argv = [process.argv[0], process.argv[1], presetName, ...remaining];
-
-const orchestrator = new Orchestrator(configPath, { logLevel });
-orchestrator.start(presetName);
+module.exports = { run };

package/src/interactive.js

@@ -0,0 +1,318 @@
+const termkit = require('terminal-kit');
+const { savePreset } = require('./save-preset');
+const { resolveServiceExecutionGraph } = require('./dependency-resolver');
+const log = require('./logger');
+
+/**
+ * Full-screen interactive selection TUI (terminal-kit).
+ *
+ * Two tabs — "Presets" and "Services & Modes" — let the user either launch an
+ * existing preset or compose a custom selection (toggle services, pick a mode
+ * for hybrid services), optionally saving it back as a new preset.
+ *
+ * Runs to completion *before* the orchestrator takes over stdout, then fully
+ * restores the terminal. Resolves to a selection `{ name?, services, modes }`,
+ * or `null` if the user cancels (q / Esc / Ctrl+C).
+ *
+ * @param {object} config - the loaded, validated go-dev config.
+ * @param {{ configPath: string, presetName?: string }} options
+ * @returns {Promise<{ name?: string, services: string[], modes: Record<string,string> } | null>}
+ */
+function runInteractive(config, { configPath, presetName } = {}) {
+  const term = termkit.terminal;
+  const serviceNames = Object.keys(config.services ?? {});
+  const presetNames = Object.keys(config.presets ?? {});
+
+  const isHybrid = (name) => config.services[name].type === 'hybrid';
+  const modesFor = (name) => (isHybrid(name) ? Object.keys(config.services[name].modes) : ['dev']);
+  const defaultModeFor = (name) =>
+    isHybrid(name)
+      ? config.services[name].defaultMode ?? modesFor(name)[0] ?? 'dev'
+      : 'dev';
+
+  // --- state ---------------------------------------------------------------
+  const selected = new Set();
+  const chosenMode = new Map();
+  for (const name of serviceNames) chosenMode.set(name, defaultModeFor(name));
+
+  // Pre-populate from a preset when forced interactive with a preset given.
+  if (presetName && config.presets?.[presetName]) {
+    const preset = config.presets[presetName];
+    for (const s of preset.services) selected.add(s);
+    for (const [s, m] of Object.entries(preset.modes ?? {})) chosenMode.set(s, m);
+  }
+
+  const TABS = ['Services & Modes', 'Presets'];
+  let activeTab = 0; // land on Services & Modes; Tab switches to Presets
+  let cursor = 0;
+  let message = '';
+
+  // --- rendering -----------------------------------------------------------
+  function drawHeader() {
+    term.moveTo(1, 1).styleReset().bold('go-dev')(' — selezione servizi');
+    term.moveTo(1, 2);
+    TABS.forEach((label, i) => {
+      if (i === activeTab) term.bgBrightWhite.black(` ${label} `);
+      else term.bgGray.white(` ${label} `);
+      term('  ');
+    });
+  }
+
+  function drawPresets() {
+    term.moveTo(1, 4)('Preset disponibili — ↑/↓ scegli, invio avvia:');
+    if (presetNames.length === 0) {
+      term.moveTo(3, 6).gray('(nessun preset definito — usa la tab Services & Modes)');
+      return;
+    }
+    presetNames.forEach((name, i) => {
+      const marker = i === cursor ? '❯' : ' ';
+      const services = (config.presets[name].services ?? []).join(', ');
+      term.moveTo(2, 6 + i);
+      const text = `${marker} ${name}`;
+      if (i === cursor) term.brightCyan(text);
+      else term(text);
+      term.gray(`   services: ${services}`);
+    });
+  }
+
+  function drawServices() {
+    term.moveTo(1, 4)('Servizi — spazio: on/off, m: modalità, invio: avvia:');
+    if (serviceNames.length === 0) {
+      term.moveTo(3, 6).gray('(nessun servizio definito)');
+      return;
+    }
+    serviceNames.forEach((name, i) => {
+      const marker = i === cursor ? '❯' : ' ';
+      const box = selected.has(name) ? '[x]' : '[ ]';
+      term.moveTo(2, 6 + i);
+      const text = `${marker} ${box} ${name}`;
+      if (i === cursor) term.brightCyan(text);
+      else term(text);
+      const mode = isHybrid(name) ? chosenMode.get(name) : 'dev';
+      term.gray(`   mode: ${mode}${isHybrid(name) ? ' (m per cambiare)' : ''}`);
+    });
+  }
+
+  // Selection the bottom panel previews. On the Services tab it reflects the
+  // *checked* services (not the cursor); on the Presets tab, the highlighted preset.
+  function panelSelection() {
+    if (activeTab === 0) {
+      const services = serviceNames.filter((s) => selected.has(s));
+      const modes = {};
+      for (const s of services) {
+        if (isHybrid(s)) modes[s] = chosenMode.get(s);
+      }
+      return { services, modes };
+    }
+    const preset = presetNames[cursor];
+    if (!preset) return null;
+    return { services: config.presets[preset].services, modes: config.presets[preset].modes ?? {} };
+  }
+
+  // Bottom panel: the resolved selection split into labelled sections.
+  function drawPanel(top) {
+    term.moveTo(1, top).styleReset().gray('─'.repeat(Math.min(term.width, 64)));
+
+    const selection = panelSelection();
+    if (!selection) return;
+
+    let graph;
+    const previousLevel = log.getLogLevel();
+    try {
+      log.setLogLevel('error'); // silence resolver dedup warnings while previewing
+      graph = resolveServiceExecutionGraph(config, selection);
+    } catch (error) {
+      term.moveTo(3, top + 1).styleReset().red(`⚠ ${error.message}`);
+      return;
+    } finally {
+      log.setLogLevel(previousLevel);
+    }
+
+    let row = top + 1;
+    const header = (label) => {
+      if (row >= term.height - 1) return;
+      term.moveTo(1, row++).styleReset().bold(label);
+    };
+    const item = (label, style) => {
+      if (row >= term.height - 1) return;
+      term.moveTo(3, row++).styleReset();
+      style(label);
+    };
+    const blank = () => { row++; };
+
+    header('servizi principali');
+    if (graph.services.length) {
+      graph.services.forEach((s) => item(`${s.name}:${s.mode}`, (t) => term.brightWhite(t)));
+    } else {
+      item(activeTab === 0 ? '(nessun servizio selezionato)' : '(nessuno)', (t) => term.gray(t));
+    }
+
+    blank();
+    header('dipendenze');
+    if (graph.dependencies.length) {
+      graph.dependencies.forEach((d) => item(`${d.name}:${d.mode}`, (t) => term.white(t)));
+    } else {
+      item('(nessuna)', (t) => term.gray(t));
+    }
+
+    if (graph.conflicts.length) {
+      blank();
+      if (row < term.height - 1) term.moveTo(1, row++).styleReset().red('⚠ conflitti di modalità');
+      for (const { service, requests } of graph.conflicts) {
+        const where = requests
+          .map((r) => `${r.mode}${r.by ? ` (dip. di ${r.by})` : ' (primario)'}`)
+          .join(' vs ');
+        item(`${service}: ${where}`, (t) => term.yellow(t));
+      }
+      item('un solo avvio per servizio — alcune dipendenze restano non soddisfatte', (t) => term.gray(t));
+    }
+  }
+
+  function render() {
+    term.clear();
+    drawHeader();
+    if (activeTab === 0) drawServices();
+    else drawPresets();
+
+    const panelTop = 6 + Math.max(serviceNames.length, presetNames.length, 1) + 1;
+    drawPanel(panelTop);
+
+    if (message) {
+      term.moveTo(1, term.height - 1).styleReset().yellow(message);
+    }
+    term.moveTo(1, term.height).styleReset().gray(
+      ' ←/→ tab   ↑/↓ muovi   spazio on/off   m modalità   invio avvia   q esci'
+    );
+  }
+
+  // --- helpers -------------------------------------------------------------
+  function currentList() {
+    return activeTab === 0 ? serviceNames : presetNames;
+  }
+
+  function cycleMode(name) {
+    if (!isHybrid(name)) return;
+    const modes = modesFor(name);
+    const next = (modes.indexOf(chosenMode.get(name)) + 1) % modes.length;
+    chosenMode.set(name, modes[next]);
+  }
+
+  function buildCustomSelection() {
+    const services = serviceNames.filter((s) => selected.has(s));
+    const modes = {};
+    for (const s of services) {
+      if (isHybrid(s)) modes[s] = chosenMode.get(s);
+    }
+    return { name: undefined, services, modes };
+  }
+
+  // --- lifecycle -----------------------------------------------------------
+  return new Promise((resolve) => {
+    let finished = false;
+
+    function cleanup() {
+      term.removeListener('key', onKey);
+      term.grabInput(false);
+      term.hideCursor(false);
+      term.fullscreen(false);
+    }
+
+    function finish(result) {
+      if (finished) return;
+      finished = true;
+      cleanup();
+      resolve(result);
+    }
+
+    async function confirmCustom() {
+      const selection = buildCustomSelection();
+      if (selection.services.length === 0) {
+        message = 'Seleziona almeno un servizio (spazio).';
+        return render();
+      }
+
+      // Hand input over to terminal-kit's prompt helpers for the save flow.
+      term.removeListener('key', onKey);
+      term.hideCursor(false);
+
+      term.moveTo(1, term.height - 2).styleReset().eraseLine();
+      term('Salvare questa selezione come preset? [s/N] ');
+      const wantsSave = await term.yesOrNo({ yes: ['s', 'y'], no: ['n', 'ENTER', 'ESCAPE'] }).promise;
+
+      if (wantsSave) {
+        term.moveTo(1, term.height - 1).styleReset().eraseLine();
+        term('Nome del preset: ');
+        const name = ((await term.inputField().promise) || '').trim();
+        if (name) {
+          try {
+            savePreset(configPath, name, selection);
+            selection.name = name;
+          } catch (error) {
+            term.moveTo(1, term.height).styleReset().eraseLine().red(`Errore: ${error.message}`);
+            await term.yesOrNo({ yes: ['ENTER', 'y', 's'], no: ['n'] }).promise; // pausa per leggere
+          }
+        }
+      }
+
+      return finish(selection);
+    }
+
+    function onKey(name) {
+      message = '';
+
+      if (name === 'CTRL_C' || name === 'ESCAPE' || name === 'q') return finish(null);
+
+      if (name === 'TAB' || name === 'LEFT' || name === 'RIGHT') {
+        activeTab = (activeTab + 1) % TABS.length;
+        cursor = 0;
+        return render();
+      }
+
+      const list = currentList();
+      if (name === 'UP') {
+        cursor = list.length ? (cursor - 1 + list.length) % list.length : 0;
+        return render();
+      }
+      if (name === 'DOWN') {
+        cursor = list.length ? (cursor + 1) % list.length : 0;
+        return render();
+      }
+
+      if (activeTab === 1) {
+        // Presets tab
+        if (name === 'ENTER') {
+          const preset = presetNames[cursor];
+          if (!preset) return;
+          return finish({
+            name: preset,
+            services: config.presets[preset].services,
+            modes: config.presets[preset].modes ?? {},
+          });
+        }
+        return;
+      }
+
+      // Services & Modes tab
+      const svc = serviceNames[cursor];
+      if (!svc) return;
+      if (name === ' ' || name === 'SPACE') {
+        if (selected.has(svc)) selected.delete(svc);
+        else selected.add(svc);
+        return render();
+      }
+      if (name === 'm') {
+        cycleMode(svc);
+        return render();
+      }
+      if (name === 'ENTER') return confirmCustom();
+    }
+
+    term.fullscreen(true);
+    term.grabInput(true);
+    term.hideCursor(true);
+    term.on('key', onKey);
+    render();
+  });
+}
+
+module.exports = { runInteractive };

package/src/orchestrator.js

@@ -16,6 +16,7 @@ const bold = (text) => `\x1b[1m${text}\x1b[0m`;
 
 class Orchestrator {
   constructor(configPath, options = {}) {
+    this.configPath = configPath;
     this.config = loadConfig(configPath);
 
     const level = options.logLevel ?? this.config.logLevel;
@@ -29,19 +30,34 @@ class Orchestrator {
     BaseService.initialize(this.processManager, this.config.services);
   }
 
-  async start(presetName) {
+  /**
+   * @param {{ name?: string, services: string[], modes?: Record<string, string> }} selection
+   *   The service selection to run — from a preset or built interactively.
+   */
+  async start(selection) {
     try {
-      const { dependencies, services: primaryServices } = resolveServiceExecutionGraph(
+      const { dependencies, services: primaryServices, conflicts } = resolveServiceExecutionGraph(
         this.config,
-        presetName,
+        selection,
       );
 
-      log.info(bold(`Preset: ${presetName}`));
+      log.info(bold(`Preset: ${selection.name ?? 'selezione personalizzata'}`));
       log.info(`\n${bold('Resolved dependencies')}`);
       dependencies.forEach(s => log.info(` - ${colorService(s.name, s.mode)} (mode: ${colorMode(s.name, s.mode)})`));
       log.info(`\n${bold('Resolved primary services')}`);
       primaryServices.forEach(s => log.info(` - ${colorService(s.name, s.mode)} (mode: ${colorMode(s.name, s.mode)})`));
 
+      if (conflicts.length > 0) {
+        log.warn(`\n${bold('⚠ Mode conflicts')}`);
+        for (const { service, requests } of conflicts) {
+          const where = requests
+            .map(r => `${colorMode(service, r.mode)}${r.by ? ` (dep of ${r.by})` : ' (primary)'}`)
+            .join(' vs ');
+          log.warn(` - '${service}' requested in conflicting modes: ${where}.`);
+        }
+        log.warn(`   go-dev runs one instance per service, so some dependencies above may be unmet.`);
+      }
+
       const extraArgs = new Map();
       {
         const argsToParse = process.argv.slice(3);
@@ -61,7 +77,7 @@ class Orchestrator {
             }
             if (currentService == null) {
               if (isGettingService === false) {
-                throw new Error(`Invalid arguments, use format: npx go-dev ${presetName} ${serviceArgsKeyword} <service> <args>`);
+                throw new Error(`Invalid arguments, use format: npx go-dev ${selection.name ?? '<preset>'} ${serviceArgsKeyword} <service> <args>`);
               }
 
               const splitArg = arg.split(':');

package/src/process-manager.js

@@ -88,6 +88,56 @@ class ProcessManager {
     });
   }
 
+  /**
+   * Runs a command asynchronously, prefixing its output like a managed process.
+   * Used for pre-commands (literal or service-as-preCommand) so their output is
+   * attributed to the owning service instead of leaking raw to the terminal.
+   * @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.
+   * @returns {Promise<void>} Resolves when the process exits successfully.
+   */
+  runInheritedPrefixed(command, args = [], options = {}, prefix) {
+    return new Promise((resolve, reject) => {
+      if (this.cleanupInProgress) {
+        log.warn(`[ProcessManager] Skipping inherited command '${command}' during cleanup.`);
+        return resolve();
+      }
+      log.debug(`[ProcessManager] Running inherited (prefixed): ${command} ${args.join(' ')}`);
+      const proc = spawn(command, args, {
+        shell: true,
+        stdio: 'pipe',
+        ...options,
+        env: { FORCE_COLOR: '1', ...process.env, ...(options.env ?? {}) },
+      });
+
+      let lastFormatting = '';
+      const writePrefixed = (data, target) => {
+        const result = prefixLines(data.toString(), prefix, lastFormatting);
+        lastFormatting = result.lastFormatting;
+        target.write(result.prefixedText);
+      };
+      proc.stdout.on('data', (data) => writePrefixed(data, process.stdout));
+      proc.stderr.on('data', (data) => writePrefixed(data, process.stderr));
+
+      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.