go-dev 0.2.1 → 0.3.0

package/README.md

@@ -20,7 +20,9 @@ In complex monorepos, starting your development environment can be a chore. You
 *   **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`?
 
@@ -60,7 +62,7 @@ npx go-dev frontend  # Start the environment for Frontend development
 npx go-dev all       # Start the full development environment
 ```
 
-Press `Ctrl+C` at any time to gracefully shut down all running services.
+`go-dev` will automatically exit once all primary services (those directly listed in your chosen preset) have completed their execution cleanly. If you need to stop `go-dev` before all services complete, possibly because you're running a web service, press `Ctrl+C` at any time to gracefully shut down all running services.
 
 ## ⚙️ Configuration (`go-dev.yml`)
 
@@ -86,15 +88,14 @@ 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
         commands:
-          start:
-            command: [npx, rollup, -c, -w] # The primary command for development
-            directory: ./api      # Directory to run the command from
+          command: [npx, rollup, -c, -w] # The primary command for development
+          directory: ./api      # Directory to run the command from
         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 +118,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 +129,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "go-dev",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "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

@@ -24,13 +24,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([]),

package/src/orchestrator.js

@@ -43,12 +43,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 +60,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();
+        });
         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,54 @@ 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 {
         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 +241,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 +251,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 +265,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,11 @@ 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) {
     this.name = name;
     this.mode = mode;
     this.config = config;
+    this.onExit = onExit;
   }
 
   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) {
+    super(name, mode, config, onExit);
     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,21 +41,14 @@ 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 } = (Array.isArray(commands) && typeof commands[0] === 'string' ?
+      { cmdArgs: [commands], directory: [undefined] } :
+      (Array.isArray(commands) ?
         {
-          cmdArgs: mainCommand.map(({ command }) => command),
-          directory: mainCommand.map(({ directory }) => directory),
+          cmdArgs: commands.map(({ command }) => command),
+          directory: commands.map(({ directory }) => directory),
         } :
-        { cmdArgs: [mainCommand.command], directory: [mainCommand.directory] }
+        { cmdArgs: [commands.command], directory: [commands.directory] }
       )
     );
 
@@ -68,6 +66,7 @@ class CmdService extends BaseService {
           this.prefix
         ),
         true,
+        () => this.onExit?.()
       );
   
       if (!process) {
@@ -78,13 +77,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}`);
-  }
-}