go-dev 0.2.1 → 0.3.1

package/README.md

@@ -14,13 +14,15 @@ In complex monorepos, starting your development environment can be a chore. You
 
 *   **Unified Configuration:** Define all your services, their modes (e.g., `dev`, `docker`, `serve`), and dependencies in a single `go-dev.yml` file.
 *   **Service Types:**
-    *   **`cmd` services:** Run any command-line process (e.g., `npm run dev`, `rollup -w`, `python app.py`). Supports `preCommands` for setup tasks like builds.
+    *   **`cmd` services:** Run any command-line process (e.g., `npm run dev`, `rollup -w`, `python app.py`). Supports `preCommands` for setup tasks like builds. Commands can be defined in multiple flexible ways to run single or multiple processes in parallel for a service.
     *   **`docker` services:** Manage Docker containers via `docker compose`. Automatically checks container status and performs health checks.
 *   **Mode-Aware Dependencies:** Services can depend on other services running in specific modes (e.g., your `api` dev mode might depend on `frontend` in `serve` mode).
 *   **Preset-Driven Startup:** Define different "presets" (e.g., `api`, `frontend`, `all`) to easily spin up specific combinations of services tailored to your current development focus.
 *   **Automatic Dependency Resolution:** `go-dev` builds an intelligent execution graph, starting services in the correct topological order.
 *   **Centralized Logging:** Prefixes logs from each service, making it easy to follow activity from multiple concurrent processes.
-*   **Robust Cleanup:** Handles graceful shutdown of all started processes and Docker services on exit (e.g., via `Ctrl+C`).
+*   **Automatic Process Exit:** The `go-dev` process will automatically exit when all primary services (those directly listed in the chosen preset) exit cleanly (with a success code of `0`).
+*   **Precise Docker Cleanup:** `go-dev` intelligently tracks which Docker Compose services it **actively started** (i.e., those that were not already running). During cleanup, it will only stop these specific services, leaving any pre-existing containers untouched.
+*   **Robust Cleanup:** Handles graceful shutdown of all started processes and Docker services on exit (e.g., via `Ctrl+C` or automatic exit).
 
 ## 🤔 Why `go-dev`?
 
@@ -52,15 +54,35 @@ npx go-dev <preset_name> [config_path]
 *   `<preset_name>`: The name of the preset defined in your `go-dev.yml` (e.g., `api`, `frontend`, `all`).
 *   `[config_path]`: (Optional) Path to your `go-dev.yml` file. Defaults to looking for `go-dev.yml`, `.go-dev.yml`, `go-dev.yaml`, or `.go-dev.yaml` in the current directory.
 
-**Example:**
+**Passing Arguments to Service Commands:**
+
+To pass additional arguments from the command line to a specific service command, use a keyword flag followed by the target and its arguments.
+
+By default, the keyword flag is `--args-for`. This can be customized in your `go-dev.yml` using the `serviceArgsKeyword` option (e.g., `serviceArgsKeyword: pass-to`).
+
+The target for arguments is specified as `<service_name>[:<command_index>]`:
+
+Specify the target for arguments as `<service_name>:<command_index>` (e.g., `api:0`, `frontend:1`). The `command_index` is 0-based and refers to the position of the command within a service's `commands` array. If the `:<command_index>` part is omitted (e.g., just `<service_name>`), arguments are passed to the **first command (index `0`)** defined for that service.
+
+You can combine multiple keyword flag blocks for different services or specific commands.
 
 ```bash
-npx go-dev api       # Start the environment for API development
-npx go-dev frontend  # Start the environment for Frontend development
-npx go-dev all       # Start the full development environment
+npx go-dev <preset_name> [--<serviceArgsKeyword> <service_name>[:<command_index>] [args...] ] [...]
 ```
 
-Press `Ctrl+C` at any time to gracefully shut down all running services.
+Example:
+
+Consider an `api` service with two parallel commands: `api:0` (main server) and `api:1` (TypeScript compiler watch).
+
+```bash
+npx go-dev all \
+  --args-for api:0 --host 0.0.0.0 --port 8081 \
+  --args-for api:1 --pretty --diagnostics \
+  --args-for frontend --log-level verbose
+```
+*In the example above, `--args-for frontend` is equivalent to `--args-for frontend:0`.*
+
+Press `Ctrl+C` at any time to gracefully shut down all running services. `go-dev` will also automatically exit once all primary services (those directly listed in your chosen preset) have completed their execution cleanly.
 
 ## ⚙️ Configuration (`go-dev.yml`)
 
@@ -73,6 +95,10 @@ Common examples include: `go-dev.yml`, `.go-dev.yml`, and `go-dev.config.yaml`.
 ```yaml
 # go-dev.yml
 
+# Customize the keyword used to pass arguments to service commands from the CLI.
+# Change this if 'args-for' conflicts with a command your services use.
+serviceArgsKeyword: args-for # Default value
+
 # Define your individual services here
 services:
   # Example: A Docker-based PostgreSQL database
@@ -86,15 +112,27 @@ services:
   api:
     type: hybrid         # This service has multiple modes
     defaultMode: dev     # Default mode if not specified by a preset or dependency
-    # Note: The name of the modes is totally arbirtary
+    # Note: The name of the modes is totally arbitrary
     modes:
       # API in active development mode (runs directly on host)
       dev:
         type: cmd             # This mode runs a command-line process
+        # The 'commands' property can be specified in three ways:
+        # 1. As a simple array of strings (for a single command without extra options)
+        #    commands: [npx, rollup, -c, -w]
+        # 2. As a single command object (for one command with options like 'directory' or 'restartOnError')
+        #    commands:
+        #      command: [npx, rollup, -c, -w]
+        #      directory: ./api
+        #      restartOnError: true # Default is true for 'cmd' services
+        # 3. As an array of command objects (for multiple parallel commands)
         commands:
-          start:
-            command: [npx, rollup, -c, -w] # The primary command for development
+          - command: [npx, rollup, -c, -w] # The primary command for development (index 0)
             directory: ./api      # Directory to run the command from
+            # restartOnError: true # (Optional, defaults to true)
+          # Example of a second parallel command for API (index 1)
+          # - command: [npx, tsc, --watch]
+          #   directory: ./api
         dependencies:         # What this mode depends on
           - postgres          # API dev needs PostgreSQL (will use postgres's default docker mode)
           - { service: frontend, mode: serve } # API dev needs frontend running in its 'serve' mode
@@ -117,9 +155,8 @@ services:
       dev:
         type: cmd
         commands:
-          start:
-            command: [npx, rollup, -c, -w]
-            directory: ./frontend
+          command: [npx, rollup, -c, -w]
+          directory: ./frontend
         dependencies:
           # Frontend dev needs API (will use api's default docker mode for this preset)
           # Note: No direct circular dependency between dev modes.
@@ -129,12 +166,11 @@ services:
       # Frontend serving its built assets (e.g., when API depends on it)
       serve:
         type: cmd
-        preCommands: # Commands to run and await completion BEFORE the main 'start' command
+        preCommands: # Commands to run and await completion BEFORE the main command
           - [npm, --prefix, frontend, run, build] # Build frontend assets first
         commands:
-          start:
-            command: [node, ./localserver.mjs] # Then start the local server
-            directory: ./frontend
+          command: [node, ./localserver.mjs] # Then start the local server
+          directory: ./frontend
         dependencies:
           - api # Frontend serve needs API (will use api's default dev mode for this preset)
 

package/bin/go-dev

@@ -4,13 +4,12 @@ const Orchestrator = require('../src/orchestrator');
 const path = require('path');
 
 const presetName = process.argv[2];
-const configPath = process.argv[3];
 
 if (!presetName) {
-    console.error('Error: Please specify a preset to run. Usage: dev-orchestrator <preset_name> [config_path]');
+    console.error('Error: Please specify a preset to run. Usage: dev-orchestrator <preset_name>');
     process.exit(1);
 }
 
-const orchestrator = new Orchestrator(configPath);
+const orchestrator = new Orchestrator();
 
 orchestrator.start(presetName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "go-dev",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "main": "src/index.js",
   "bin": {
     "go-dev": "bin/go-dev"
@@ -9,6 +9,10 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "author": "Giuliano Collacchioni",
+  "repository": {
+    "type": "github",
+    "url": "https://github.com/Kal-Aster/go-dev"
+  },
   "license": "MIT",
   "description": "",
   "dependencies": {

package/src/config.js

@@ -15,6 +15,7 @@ const commandSchema = Joi.array().items(Joi.string().min(1)).min(1);
 const commandObjectSchema = Joi.object({
     command: commandSchema,
     directory: Joi.string().min(1).optional(),
+    restartOnError: Joi.boolean().optional(),
 })
 const commandConfigSchema = Joi.alternatives().try(
     commandSchema,
@@ -24,13 +25,10 @@ const commandConfigSchema = Joi.alternatives().try(
 const cmdServiceConfigSchema = Joi.object({
   type: Joi.string().valid('cmd').required(),
   preCommands: Joi.array().items(commandConfigSchema).default([]),
-  commands: Joi.object().pattern(
-    Joi.string(),
-    Joi.alternatives().try(
-      commandConfigSchema,
-      Joi.array().items(commandObjectSchema).min(1)
-    )
-  ).min(1).required(),
+  commands: Joi.alternatives().try(
+    commandConfigSchema,
+    Joi.array().items(commandObjectSchema).min(1)
+  ),
   defaultCommand: Joi.string().default('start'),
   directory: Joi.string(),
   dependencies: Joi.array().items(dependencyEntrySchema).default([]),
@@ -62,6 +60,7 @@ const serviceSchema = Joi.alternatives().try(
 );
 
 const configSchema = Joi.object({
+  serviceArgsKeyword: Joi.string().min(1).optional(),
   services: Joi.object().pattern(Joi.string(), serviceSchema).required(),
   presets: Joi.object().pattern(
     Joi.string(),
@@ -112,6 +111,8 @@ function loadConfig(configPath) {
   
   const configContent = fs.readFileSync(configPath, 'utf8');
   const config = yaml.load(configContent);
+
+  console.log(config.services.api.modes);
   
   const { error, value } = configSchema.validate(config);
   

package/src/orchestrator.js

@@ -33,6 +33,63 @@ class Orchestrator {
       console.log('--- Resolved Primary Services to Run ---');
       primaryServices.forEach(s => console.log(` - ${s.name} (mode: ${s.mode})`));
 
+      const extraArgs = new Map();
+      {
+        const argsToParse = process.argv.slice(3);
+        if (argsToParse.length > 0) {
+          console.log(`--- Gathering args to pass to services ---`);
+          const serviceArgsKeyword = `--${this.config.serviceArgsKeyword ?? 'args-for'}`;
+          let isGettingService = false;
+          let currentService = null;
+          let currentIndex = 0;
+          let argsToPass = null;
+          for (const arg of argsToParse) {
+            if (arg === serviceArgsKeyword) {
+              isGettingService = true;
+              currentService = null;
+              currentIndex = 0;
+              continue;
+            }
+            if (currentService == null) {
+              if (isGettingService === false) {
+                throw new Error(`Invalid arguments, use format: npx go-dev ${presetName} ${serviceArgsKeyword} <service> <args>`);
+              }
+
+              const splitArg = arg.split(':');
+              if (splitArg.length > 2) {
+                throw new Error(`Invalid service name + index '${arg}': should be <service> or <service>:<command_index>`);
+              }
+
+              const index = splitArg.length > 1 ? parseInt(splitArg[1]) : 0;;
+              if (splitArg.length > 1 && `${index}` !== splitArg[1]) {
+                throw new Error(`Invalid service name + index '${arg}': should be <service> or <service>:<command_index>`);
+              }
+
+              currentService = splitArg[0];
+              currentIndex = index;
+              argsToPass = extraArgs.get(currentService) ?? [];
+              extraArgs.set(currentService, argsToPass);
+              isGettingService = false;
+              continue;
+            }
+
+            let args = argsToPass[currentIndex];
+            if (args == null) {
+              args = [];
+              argsToPass[currentIndex] = args;
+            }
+
+            args.push(arg);
+          }
+
+          for (const [service, indexedArgs] of extraArgs.entries()) {
+            indexedArgs.forEach((args, index) => {
+              console.log(`Extra args for service '${service}:${index}': [${args.join(', ')}]`);
+            });
+          }
+        }
+      }
+
       console.log('\n--- Starting Dependencies ---');
       for (const { name, mode, config } of dependencies) {
         if (this.activeServiceInstances.has(name)) {
@@ -43,12 +100,13 @@ class Orchestrator {
         if (!ServiceClass) {
           throw new Error(`Unknown service type '${config.type}' for service '${name}'.`);
         }
-        const serviceInstance = new ServiceClass(name, mode, config);
+        const serviceInstance = new ServiceClass(name, mode, config, () => {});
         this.activeServiceInstances.set(name, serviceInstance);
         await serviceInstance.start();
       }
 
       console.log('\n--- Starting Primary Services ---');
+      const activePrimaryServices = new Map();
       const primaryServicePromises = [];
       for (const { name, mode, config } of primaryServices) {
         if (this.activeServiceInstances.has(name)) {
@@ -59,8 +117,16 @@ class Orchestrator {
         if (!ServiceClass) {
           throw new Error(`Unknown service type '${config.type}' for service '${name}'.`);
         }
-        const serviceInstance = new ServiceClass(name, mode, config);
+        const serviceInstance = new ServiceClass(name, mode, config, () => {
+          activePrimaryServices.delete(name);
+          if (activePrimaryServices.size > 0) {
+            return;
+          }
+
+          this.cleanup();
+        }, extraArgs.get(name));
         this.activeServiceInstances.set(name, serviceInstance);
+        activePrimaryServices.set(name, serviceInstance);
         primaryServicePromises.push(serviceInstance.start());
       }
       await Promise.all(primaryServicePromises);

package/src/process-manager.js

@@ -93,10 +93,12 @@ class ProcessManager {
    * @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} restartOnExit - Whether to restart the process if it exits with non-zero code.
+   * @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, restartOnExit) {
+  startManagedProcess(command, args, options, prefix, restartOnError, onExit, processReference) {
     if (this.cleanupInProgress) {
       console.warn(`[ProcessManager] Skipping managed process '${command}' during cleanup.`);
       return null;
@@ -107,13 +109,18 @@ class ProcessManager {
       )} (prefix: ${prefix})`,
     );
 
-    const proc = spawn(command, args, {
+    if (processReference == null) {
+      processReference = {}
+    }
+
+    const startedProcess = spawn(command, args, {
       shell: true,
       stdio: 'pipe',
       ...options,
     });
+    processReference.process = startedProcess;
 
-    proc.stdout.on('data', (data) => {
+    startedProcess.stdout.on('data', (data) => {
       let prefixedData = data.toString().split('\n').map(line => `${prefix} ${line}`).join('\n');
       if (prefixedData.endsWith(`${prefix} `)) {
           prefixedData = prefixedData.slice(0, -(`${prefix} `).length);
@@ -124,7 +131,7 @@ class ProcessManager {
       prefixedData = prefixedData.replace(/\x1b\[(?:2J|3J|H)/gi, '');
       process.stdout.write(prefixedData);
     });
-    proc.stderr.on('data', (data) => {
+    startedProcess.stderr.on('data', (data) => {
       let prefixedData = data.toString().split('\n').map(line => `${prefix} ${line}`).join('\n');
       if (prefixedData.endsWith(`${prefix} `)) {
           prefixedData = prefixedData.slice(0, -(`${prefix} `).length);
@@ -136,49 +143,56 @@ class ProcessManager {
       process.stderr.write(prefixedData);
     });
 
-    this.managedProcesses.add(proc);
+    this.managedProcesses.add(startedProcess);
 
-    proc.on('error', (err) => {
+    startedProcess.on('error', (err) => {
       console.error(
         `[ProcessManager] Error starting managed process '${command}': ${err.message}`,
       );
-      this.managedProcesses.delete(proc);
+      this.managedProcesses.delete(startedProcess);
     });
 
-    proc.on('exit', (code, signal) => {
-      if (!this.managedProcesses.has(proc)) {
+    startedProcess.on('exit', (code) => {
+      if (!this.managedProcesses.has(startedProcess)) {
         return;
       }
 
-      this.managedProcesses.delete(proc);
+      this.managedProcesses.delete(startedProcess);
       if (this.cleanupInProgress) {
         console.log(
-          `[ProcessManager] Managed process '${command}' (PID: ${proc.pid}) exited due to cleanup.`,
+          `[ProcessManager] Managed process '${command}' (PID: ${startedProcess.pid}) exited due to cleanup.`,
         );
         return;
       }
 
       if (code !== 0) {
         console.error(
-          `[ProcessManager] Managed process '${command}' (PID: ${proc.pid}) exited with code ${code}.`,
+          `[ProcessManager] Managed process '${command}' (PID: ${startedProcess.pid}) exited with code ${code}.`,
         );
-        if (restartOnExit) {
+        if (restartOnError) {
           console.warn(
             `[ProcessManager] Restarting managed process '${command}'...`,
           );
-          this.startManagedProcess(command, args, options, prefix, restartOnExit);
+          this.startManagedProcess(command, args, options, prefix, restartOnError, onExit, processReference);
+        } else {
+          onExit?.();
         }
       } else {
         console.log(
-          `[ProcessManager] Managed process '${command}' (PID: ${proc.pid}) exited cleanly.`,
+          `[ProcessManager] Managed process '${command}' (PID: ${startedProcess.pid}) exited cleanly.`,
         );
+        onExit?.();
       }
     });
 
-    return proc;
+    return processReference;
   }
 
   killProcess(process) {
+    if (process.killed || process.exitCode != null) {
+      return;
+    }
+
     this.managedProcesses.delete(process);
 
     return new Promise((resolve, reject) => {
@@ -229,7 +243,7 @@ class ProcessManager {
     }
     for (let index = this.managedProcesses.length - 1; index >= 0; index--) {
       const process = this.managedProcesses[index];
-      if (process.killed) {
+      if (process.killed || process.exitCode != null) {
         this.managedProcesses.splice(index, 1);
       }
     }
@@ -239,7 +253,7 @@ class ProcessManager {
     console.log('\n[ProcessManager] Initiating cleanup of managed processes...');
 
     for (const proc of [...this.managedProcesses]) {
-      if (proc.killed) {
+      if (proc.killed || proc.exitCode != null) {
         continue;
       }
 
@@ -253,7 +267,7 @@ class ProcessManager {
     await new Promise(resolve => setTimeout(resolve, 500));
 
     for (const proc of [...this.managedProcesses]) {
-      if (proc.killed) {
+      if (proc.killed || proc.exitCode != null) {
         continue;
       }
 

package/src/services/base.js

@@ -28,10 +28,12 @@ class BaseService {
    * @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) {
+  constructor(name, mode, config, onExit, extraArgs) {
     this.name = name;
     this.mode = mode;
     this.config = config;
+    this.onExit = onExit;
+    this.extraArgs = extraArgs;
   }
 
   async start() {

package/src/services/cmd.js

@@ -1,8 +1,8 @@
 const { BaseService } = require('./base');
 
 class CmdService extends BaseService {
-  constructor(name, mode, config) {
-    super(name, mode, config);
+  constructor(name, mode, config, onExit, extraArgs) {
+    super(name, mode, config, onExit, extraArgs);
     this.prefix = `${name}:${mode}:`;
     this.processes = [];
   }
@@ -10,7 +10,12 @@ class CmdService extends BaseService {
   async start() {
     console.log(`[${this.name}:${this.mode}] Starting cmd service...`);
 
-    const { preCommands, commands, defaultCommand } = this.config;
+    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...`);
@@ -36,38 +41,46 @@ class CmdService extends BaseService {
       console.log(`[${this.name}:${this.mode}] Pre-commands completed.`);
     }
 
-    const mainCommand = commands[defaultCommand];
-    if (!mainCommand) {
-      throw new Error(
-        `[${this.name}:${this.mode}] Default command '${defaultCommand}' not found for service.`,
-      );
-    }
-
-    const { cmdArgs, directory } = (Array.isArray(mainCommand) && typeof mainCommand[0] === 'string' ?
-      { cmdArgs: [mainCommand], directory: [undefined] } :
-      (Array.isArray(mainCommand) ?
+    const { cmdArgs, directory, restartOnError } = (Array.isArray(commands) && typeof commands[0] === 'string' ?
+      { cmdArgs: [commands], directory: [undefined], restartOnError: [undefined] } :
+      (Array.isArray(commands) ?
         {
-          cmdArgs: mainCommand.map(({ command }) => command),
-          directory: mainCommand.map(({ directory }) => directory),
+          cmdArgs: commands.map(({ command }) => command),
+          directory: commands.map(({ directory }) => directory),
+          restartOnError: commands.map(({ restartOnError }) => restartOnError),
         } :
-        { cmdArgs: [mainCommand.command], directory: [mainCommand.directory] }
+        {
+          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 = cmdArgs[index];
-      const cwd = directory[index];
+
+      const extraArgs = this.extraArgs?.[index] ?? [];
 
       const process = CmdService._processManager.startManagedProcess(
         command[0],
-        command.slice(1),
-        { cwd },
+        command.slice(1).concat(extraArgs),
+        { cwd: directory[index] },
         (useProcessIndex ?
           `${this.prefix}${index}:` :
           this.prefix
         ),
-        true,
+        restartOnError[index],
+        () => {
+          exitedProcess[index] = true;
+          if (exitedProcess.some(exited => !exited)) {
+            return;
+          }
+
+          this.onExit?.();
+        }
       );
   
       if (!process) {
@@ -78,13 +91,13 @@ class CmdService extends BaseService {
 
       this.processes.push(process);
       console.log(
-        `[${this.name}:${this.mode}] Process started (PID: ${process.pid}).`,
+        `[${this.name}:${this.mode}] Process started (PID: ${process.process.pid}).`,
       );
     }
   }
 
   async stop() {
-    const promises = this.processes.map(process => {
+    const promises = this.processes.map(({ process }) => {
       console.log(`[${this.name}:${this.mode}] Stopping process (PID: ${process.pid}).`);
       return CmdService._processManager.killProcess(process);
     });

package/src/services/docker.js

@@ -1,8 +1,8 @@
 const { BaseService } = require('./base');
 
 class DockerService extends BaseService {
-  /** @type {Set<string>} */
-  static _composeFilesToStop = new Set();
+  /** @type {Map<string, string[]>} */
+  static _servicesToStop = new Map();
 
   static async cleanup() {
     if (!DockerService._processManager) {
@@ -10,23 +10,23 @@ class DockerService extends BaseService {
       return;
     }
 
-    if (DockerService._composeFilesToStop.size > 0) {
+    if (DockerService._servicesToStop.size > 0) {
       console.log('[DockerService] Stopping all docker services from used compose files...');
-      for (const composeFile of DockerService._composeFilesToStop) {
+      for (const [composeFile, services] of this._servicesToStop.entries()) {
         try {
-          console.log(`[DockerService] Running 'docker compose -f ${composeFile} stop'`);
+          console.log(`[DockerService] Stopping services ${services.map(service => `'${service}'`).join(', ')} of '${composeFile}'`);
           DockerService._processManager.runSync(
             'docker',
-            ['compose', '-f', composeFile, 'stop'],
+            ['compose', '-f', composeFile, 'stop', ...services],
             { stdio: 'inherit' },
           );
         } catch (error) {
           console.error(
-            `[DockerService] Failed to execute 'docker compose -f ${composeFile} stop': ${error.message}`,
+            `[DockerService] Failed to stop services of '${composeFile}': ${error.message}`,
           );
         }
       }
-      DockerService._composeFilesToStop.clear();
+      DockerService._servicesToStop.clear();
     } else {
       console.log('[DockerService] No docker services were started by orchestrator, skipping global stop.');
     }
@@ -47,16 +47,33 @@ class DockerService extends BaseService {
       console.log(
         `[${this.name}:${this.mode}] Docker container for '${this.dockerServiceName}' is already running.`,
       );
-      DockerService._composeFilesToStop.add(this.dockerComposeFile);
     } else {
       console.log(`[${this.name}:${this.mode}] Bringing up docker service '${this.dockerServiceName}'...`);
       try {
+        const servicesBeforeStart = this._getCurrentlyRunningServices();
         await DockerService._processManager.runInherited(
           'docker',
           ['compose', '-f', this.dockerComposeFile, 'up', this.dockerServiceName, '-d'],
         );
-        DockerService._composeFilesToStop.add(this.dockerComposeFile);
+        const servicesAfterStart = this._getCurrentlyRunningServices();
+        let servicesOfComposeFile = DockerService._servicesToStop.get(this.dockerComposeFile);
+        if (servicesOfComposeFile == null) {
+          servicesOfComposeFile = [];
+        }
+        const newServices = servicesAfterStart.filter(service => {
+          return !(
+            servicesBeforeStart.includes(service) ||
+            servicesOfComposeFile.includes(service)
+          );
+        });
+        DockerService._servicesToStop.set(
+          this.dockerComposeFile,
+          servicesOfComposeFile.concat(newServices)
+        );
         console.log(`[${this.name}:${this.mode}] Docker service '${this.dockerServiceName}' brought up.`);
+        if (newServices.length > 1) {
+          console.log(`[${this.name}:${this.mode}] Dependency service${newServices.length > 2 ? 's' : ''} for '${this.dockerServiceName}': ${newServices.filter(service => service.name !== this.dockerServiceName).join(', ')}`);
+        }
       } catch (error) {
         throw new Error(
           `[${this.name}:${this.mode}] Failed to bring up docker service '${this.dockerServiceName}': ${error.message}`,
@@ -88,6 +105,23 @@ class DockerService extends BaseService {
     return await this._checkServiceHealthiness();
   }
 
+  _getCurrentlyRunningServices() {
+    try {
+      const services = DockerService._processManager.runSync(
+        'docker',
+        ['compose', '-f', this.dockerComposeFile, 'ps', '--services'],
+      );
+      return (services
+        .split('\n')
+        .map(serviceName => serviceName.trim())
+        .filter(serviceName => serviceName !== '')
+      );
+    } catch (error) {
+      // console.warn(...);
+    }
+    return null;
+  }
+
   _getContainerName() {
     if (this.containerName) {
       return this.containerName;
@@ -143,7 +177,7 @@ class DockerService extends BaseService {
         );
 
         if (healthStatus === 'healthy' || healthStatus === 'none') {
-          console.log(`[${this.name}:${this.mode}] Container '${containerName}' healty!\n`);
+          console.log(`[${this.name}:${this.mode}] Container '${containerName}' healthy!`);
           return true;
         }
 

package/test.js

@@ -1,136 +0,0 @@
-const { loadConfig } = require('./src/config');
-const { resolveServiceExecutionGraph } = require('./src/dependency-resolver');
-const fs = require('fs');
-
-const testConfigContent = `
-composeFile: infrastructure/docker-compose.yml
-
-services:
-  postgres:
-    type: docker
-    service: postgres
-    healthCheck: true
-
-  api:
-    type: hybrid
-    defaultMode: dev
-    modes:
-      dev:
-        type: cmd
-        commands:
-          start: [npx, rollup, -c, -w]
-        directory: ./api
-        dependencies:
-          - postgres
-          - { service: frontend, mode: serve }
-
-      docker:
-        type: docker
-        service: api
-        healthCheck: true
-        dependencies:
-          - postgres
-
-  frontend:
-    type: hybrid
-    defaultMode: dev
-    modes:
-      dev:
-        type: cmd
-        commands:
-          start: [npx, rollup, -c, -w]
-        directory: ./frontend
-        dependencies:
-          - { service: api, mode: docker }
-
-      serve:
-        type: cmd
-        preCommands:
-          - [npm, --prefix, frontend, run, build]
-        commands:
-          start: [node, ./localserver.mjs]
-        directory: ./frontend
-        dependencies:
-          - api
-
-presets:
-  api:
-    services: [api]
-
-  frontend:
-    services: [frontend]
-
-  all:
-    services: [api, frontend]
-
-  # Example of a preset that would cause a cycle if dependencies were set up naively
-  # (and without the \`dev\` modes being peers)
-  # cycle-test:
-  #   services: [api, frontend]
-  #   modes:
-  #     api: dev
-  #     frontend: cycle-dev # Imagine 'cycle-dev' depends on 'api:dev'
-  #     # To trigger a cycle, you'd need api:dev -> frontend:dev and frontend:dev -> api:dev
-
-`;
-
-const testConfigPath = 'temp-dev-orchestrator.yml';
-fs.writeFileSync(testConfigPath, testConfigContent);
-
-console.log('--- Testing Dependency Resolver ---');
-
-try {
-  const config = loadConfig(testConfigPath);
-  console.log('✅ Config loaded successfully');
-
-  console.log('\n--- Resolving "api" preset ---');
-  const apiExecutionGraph = resolveServiceExecutionGraph(config, 'api');
-  console.log('✅ "api" preset resolved successfully.');
-  console.log('Dependencies:');
-  apiExecutionGraph.dependencies.forEach((node) => {
-    console.log(`  - ${node.name} (mode: ${node.mode})`);
-  });
-  console.log('Services:');
-  apiExecutionGraph.services.forEach((node) => {
-    console.log(`  - ${node.name} (mode: ${node.mode})`);
-  });
-  
-  console.log('\n--- Resolving "frontend" preset ---');
-  const frontendExecutionGraph = resolveServiceExecutionGraph(config, 'frontend');
-  console.log('✅ "frontend" preset resolved successfully.');
-  console.log('Dependencies:');
-  frontendExecutionGraph.dependencies.forEach((node) => {
-    console.log(`  - ${node.name} (mode: ${node.mode})`);
-  });
-  console.log('Services:');
-  frontendExecutionGraph.services.forEach((node) => {
-    console.log(`  - ${node.name} (mode: ${node.mode})`);
-  });
-
-  console.log('\n--- Resolving "all" preset ---');
-  const allExecutionGraph = resolveServiceExecutionGraph(config, 'all');
-  console.log('✅ "all" preset resolved successfully.');
-  console.log('Dependencies:');
-  allExecutionGraph.dependencies.forEach((node) => {
-    console.log(`  - ${node.name} (mode: ${node.mode})`);
-  });
-  console.log('Services:');
-  allExecutionGraph.services.forEach((node) => {
-    console.log(`  - ${node.name} (mode: ${node.mode})`);
-  });
-
-  console.log('\n--- Testing non-existent preset ---');
-  try {
-    resolveServiceExecutionGraph(config, 'non-existent');
-  } catch (error) {
-    console.log(`✅ Caught expected error: ${error.message}`);
-  }
-} catch (error) {
-  console.error('❌ An unexpected error occurred during testing:', error);
-} finally {
-  // Clean up the temporary config file
-  if (fs.existsSync(testConfigPath)) {
-    fs.unlinkSync(testConfigPath);
-    console.log(`\nCleaned up temporary config file: ${testConfigPath}`);
-  }
-}