go-dev 0.3.0 → 0.3.1

package/README.md

@@ -14,7 +14,7 @@ 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.
@@ -54,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...] ] [...]
 ```
 
-`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.
+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`)
 
@@ -75,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
@@ -93,9 +117,22 @@ services:
       # 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:
-          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 (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

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.3.0",
+  "version": "0.3.1",
   "main": "src/index.js",
   "bin": {
     "go-dev": "bin/go-dev"

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,
@@ -59,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(),
@@ -109,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)) {
@@ -67,7 +124,7 @@ class Orchestrator {
           }
 
           this.cleanup();
-        });
+        }, extraArgs.get(name));
         this.activeServiceInstances.set(name, serviceInstance);
         activePrimaryServices.set(name, serviceInstance);
         primaryServicePromises.push(serviceInstance.start());

package/src/process-manager.js

@@ -174,6 +174,8 @@ class ProcessManager {
             `[ProcessManager] Restarting managed process '${command}'...`,
           );
           this.startManagedProcess(command, args, options, prefix, restartOnError, onExit, processReference);
+        } else {
+          onExit?.();
         }
       } else {
         console.log(

package/src/services/base.js

@@ -28,11 +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, onExit) {
+  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, onExit) {
-    super(name, mode, config, onExit);
+  constructor(name, mode, config, onExit, extraArgs) {
+    super(name, mode, config, onExit, extraArgs);
     this.prefix = `${name}:${mode}:`;
     this.processes = [];
   }
@@ -41,32 +41,46 @@ class CmdService extends BaseService {
       console.log(`[${this.name}:${this.mode}] Pre-commands completed.`);
     }
 
-    const { cmdArgs, directory } = (Array.isArray(commands) && typeof commands[0] === 'string' ?
-      { cmdArgs: [commands], directory: [undefined] } :
+    const { cmdArgs, directory, restartOnError } = (Array.isArray(commands) && typeof commands[0] === 'string' ?
+      { cmdArgs: [commands], directory: [undefined], restartOnError: [undefined] } :
       (Array.isArray(commands) ?
         {
           cmdArgs: commands.map(({ command }) => command),
           directory: commands.map(({ directory }) => directory),
+          restartOnError: commands.map(({ restartOnError }) => restartOnError),
         } :
-        { cmdArgs: [commands.command], directory: [commands.directory] }
+        {
+          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,
-        () => this.onExit?.()
+        restartOnError[index],
+        () => {
+          exitedProcess[index] = true;
+          if (exitedProcess.some(exited => !exited)) {
+            return;
+          }
+
+          this.onExit?.();
+        }
       );
   
       if (!process) {