go-dev 0.1.2 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "go-dev",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "main": "src/index.js",
   "bin": {
     "go-dev": "bin/go-dev"

package/src/config.js

@@ -12,12 +12,13 @@ const dependencyEntrySchema = Joi.alternatives().try(
 );
 
 const commandSchema = Joi.array().items(Joi.string().min(1)).min(1);
+const commandObjectSchema = Joi.object({
+    command: commandSchema,
+    directory: Joi.string().min(1).optional(),
+})
 const commandConfigSchema = Joi.alternatives().try(
     commandSchema,
-    Joi.object({
-        command: commandSchema,
-        directory: Joi.string().min(1),
-    })
+    commandObjectSchema
 );
 
 const cmdServiceConfigSchema = Joi.object({
@@ -25,7 +26,10 @@ const cmdServiceConfigSchema = Joi.object({
   preCommands: Joi.array().items(commandConfigSchema).default([]),
   commands: Joi.object().pattern(
     Joi.string(),
-    commandConfigSchema
+    Joi.alternatives().try(
+      commandConfigSchema,
+      Joi.array().items(commandObjectSchema).min(1)
+    )
   ).min(1).required(),
   defaultCommand: Joi.string().default('start'),
   directory: Joi.string(),

package/src/process-manager.js

@@ -1,5 +1,6 @@
-// src/process-manager.js
 const { spawn, spawnSync } = require('child_process');
+const { appendFileSync } = require('fs');
+
 
 class ProcessManager {
   constructor() {
@@ -120,6 +121,7 @@ class ProcessManager {
       if (!prefixedData.endsWith('\n')) {
           prefixedData = prefixedData + '\n';
       }
+      prefixedData = prefixedData.replace(/\x1b\[(?:2J|3J|H)/gi, '');
       process.stdout.write(prefixedData);
     });
     proc.stderr.on('data', (data) => {
@@ -130,6 +132,7 @@ class ProcessManager {
       if (!prefixedData.endsWith('\n')) {
           prefixedData = prefixedData + '\n';
       }
+      prefixedData = prefixedData.replace(/\x1b\[(?:2J|H)/gi, '');
       process.stderr.write(prefixedData);
     });
 
@@ -143,6 +146,10 @@ class ProcessManager {
     });
 
     proc.on('exit', (code, signal) => {
+      if (!this.managedProcesses.has(proc)) {
+        return;
+      }
+
       this.managedProcesses.delete(proc);
       if (this.cleanupInProgress) {
         console.log(
@@ -171,6 +178,47 @@ class ProcessManager {
     return proc;
   }
 
+  killProcess(process) {
+    this.managedProcesses.delete(process);
+
+    return new Promise((resolve, reject) => {
+      let exited = false;
+      const onExit = () => {
+        exited = true;
+        resolve();
+      };
+      process.on('exit', onExit);
+
+      setTimeout(() => {
+        if (exited) {
+          return;
+        }
+
+        console.error(`[ProcessManager] Timeout reached for process interruption ${process.pid}`);
+        try {
+          process.kill('SIGKILL');
+        } catch (e) {
+          console.error(`[ProcessManager] Error force killing process ${process.pid}: ${e.message}`);
+          reject(e);
+        }
+      }, 500);
+
+      try {
+        process.kill('SIGTERM');
+        return;
+      } catch (e) {
+        console.error(`[ProcessManager] Error signaling process ${process.pid}: ${e.message}`);
+      }
+
+      try {
+        process.kill('SIGKILL');
+      } catch (e) {
+        console.error(`[ProcessManager] Error force killing process ${process.pid}: ${e.message}`);
+        reject(e);
+      }
+    });
+  }
+
   /**
    * Kills all currently managed child processes.
    */
@@ -179,11 +227,22 @@ class ProcessManager {
       console.log('[ProcessManager] Cleanup of managed processes already in progress, skipping.');
       return;
     }
+    for (let index = this.managedProcesses.length - 1; index >= 0; index--) {
+      const process = this.managedProcesses[index];
+      if (process.killed) {
+        this.managedProcesses.splice(index, 1);
+      }
+    }
+
     this.cleanupInProgress = true;
 
     console.log('\n[ProcessManager] Initiating cleanup of managed processes...');
 
     for (const proc of [...this.managedProcesses]) {
+      if (proc.killed) {
+        continue;
+      }
+
       console.log(`[ProcessManager] Killing managed process PID: ${proc.pid}`);
       try {
         proc.kill('SIGTERM');

package/src/services/cmd.js

@@ -4,7 +4,7 @@ class CmdService extends BaseService {
   constructor(name, mode, config) {
     super(name, mode, config);
     this.prefix = `${name}:${mode}:`;
-    this.process = null;
+    this.processes = [];
   }
 
   async start() {
@@ -17,7 +17,7 @@ class CmdService extends BaseService {
       for (const command of preCommands) {
         const { cmdArgs, directory } = (Array.isArray(command) ?
           { cmdArgs: command } :
-          { cmdArgs: command.command, cmdArgs: command.directory }
+          { cmdArgs: command.command, directory: command.directory }
         );
         try {
           CmdService._processManager.runSync(cmdArgs[0], cmdArgs.slice(1), {
@@ -25,6 +25,7 @@ class CmdService extends BaseService {
             stdio: 'inherit',
           });
         } catch (error) {
+          console.log({ cmdArgs });
           throw new Error(
             `[${this.name}:${this.mode}] Pre-command failed: ${cmdArgs.join(
               ' ',
@@ -42,39 +43,54 @@ class CmdService extends BaseService {
       );
     }
 
-    const { cmdArgs, directory } = (Array.isArray(mainCommand) ?
-      { cmdArgs: mainCommand } :
-      { cmdArgs: mainCommand.command, directory: mainCommand.directory }
+    const { cmdArgs, directory } = (Array.isArray(mainCommand) && typeof mainCommand[0] === 'string' ?
+      { cmdArgs: [mainCommand], directory: [undefined] } :
+      (Array.isArray(mainCommand) ?
+        {
+          cmdArgs: mainCommand.map(({ command }) => command),
+          directory: mainCommand.map(({ directory }) => directory),
+        } :
+        { cmdArgs: [mainCommand.command], directory: [mainCommand.directory] }
+      )
     );
 
-    this.process = CmdService._processManager.startManagedProcess(
-      cmdArgs[0],
-      cmdArgs.slice(1),
-      { cwd: directory },
-      this.prefix,
-      true,
-    );
+    const useProcessIndex = cmdArgs.length > 1;
+    for (let index = 0; index < cmdArgs.length; index++) {
+      const command = cmdArgs[index];
+      const cwd = directory[index];
 
-    if (!this.process) {
-      throw new Error(
-        `[${this.name}:${this.mode}] Failed to spawn main process: ${cmdArgs.join(' ')}`,
+      const process = CmdService._processManager.startManagedProcess(
+        command[0],
+        command.slice(1),
+        { cwd },
+        (useProcessIndex ?
+          `${this.prefix}${index}:` :
+          this.prefix
+        ),
+        true,
+      );
+  
+      if (!process) {
+        throw new Error(
+          `[${this.name}:${this.mode}] Failed to spawn process: ${command.join(' ')}`,
+        );
+      }
+
+      this.processes.push(process);
+      console.log(
+        `[${this.name}:${this.mode}] Process started (PID: ${process.pid}).`,
       );
     }
-    console.log(
-      `[${this.name}:${this.mode}] Main process started (PID: ${this.process.pid}).`,
-    );
   }
 
   async stop() {
-    if (this.process) {
-      console.log(`[${this.name}:${this.mode}] Stopping main process (PID: ${this.process.pid}).`);
-      try {
-        this.process.kill('SIGTERM');
-      } catch (e) {
-        console.error(`[${this.name}:${this.mode}] Error signaling process ${this.process.pid}: ${e.message}`);
-      }
-      this.process = null;
-    }
+    const promises = this.processes.map(process => {
+      console.log(`[${this.name}:${this.mode}] Stopping process (PID: ${process.pid}).`);
+      return CmdService._processManager.killProcess(process);
+    });
+    this.processes.splice(0, this.processes.length);
+
+    await Promise.all(promises);
   }
 }
 

package/src/services/docker.js

@@ -80,7 +80,6 @@ class DockerService extends BaseService {
   }
 
   async stop() {
-    // The static cleanup method will handle the actual docker compose stop.
     console.log(`[${this.name}:${this.mode}] Relying on orchestrator's static docker compose stop for '${this.dockerServiceName}'.`);
     this.containerName = null;
   }
@@ -94,7 +93,6 @@ class DockerService extends BaseService {
       return this.containerName;
     }
     try {
-      // Access processManager statically
       const name = DockerService._processManager.runSync(
         'docker',
         ['compose', '-f', this.dockerComposeFile, 'ps', '-a', '-q', this.dockerServiceName],
@@ -115,7 +113,6 @@ class DockerService extends BaseService {
       return null;
     }
     try {
-      // Access processManager statically
       return DockerService._processManager.runSync(
         'docker',
         ['container', 'inspect', '-f', '{{.State.Status}}', containerName],
@@ -132,15 +129,13 @@ class DockerService extends BaseService {
       throw new Error(`[${this.name}:${this.mode}] Cannot check health: Container for '${this.dockerServiceName}' not found.`);
     }
 
-    process.stdout.write(`[${this.name}:${this.mode}] Checking healthiness for '${containerName}'`);
+    console.log(`[${this.name}:${this.mode}] Checking healthiness for '${containerName}'`);
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       if (attempt > 1) {
-        process.stdout.write(".");
         await new Promise(resolve => setTimeout(resolve, delayMs));
       }
 
       try {
-        // Access processManager statically
         const healthStatus = DockerService._processManager.runSync(
           'docker',
           ['container', 'inspect', '-f', '{{.State.Health.Status}}', containerName],
@@ -148,7 +143,7 @@ class DockerService extends BaseService {
         );
 
         if (healthStatus === 'healthy' || healthStatus === 'none') {
-          process.stdout.write(" Healthy!\n");
+          console.log(`[${this.name}:${this.mode}] Container '${containerName}' healty!\n`);
           return true;
         }
 
@@ -156,15 +151,12 @@ class DockerService extends BaseService {
           continue;
         }
 
-        process.stdout.write(` Status: ${healthStatus}\n`);
         throw new Error(`[${this.name}:${this.mode}] Container '${containerName}' is in unexpected health state: ${healthStatus}`);
       } catch (error) {
-        process.stdout.write(` Error: ${error.message}\n`);
         throw new Error(`[${this.name}:${this.mode}] Failed to check health for '${containerName}': ${error.message}`);
       }
     }
 
-    process.stdout.write("\n");
     throw new Error(`[${this.name}:${this.mode}] Service '${this.dockerServiceName}' wasn't healthy in time after ${maxAttempts} attempts.`);
   }
 }