feat: add auto-dev environment with build and server functionality

auto-dev.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+
+const { spawn } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+// Colors for console output
+const colors = {
+  reset: "\x1b[0m",
+  bright: "\x1b[1m",
+  green: "\x1b[32m",
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+};
+
+const log = {
+  info: (msg) => console.log(`${colors.blue}ℹ${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}✅${colors.reset} ${msg}`),
+  error: (msg) => console.log(`${colors.red}❌${colors.reset} ${msg}`),
+  warning: (msg) => console.log(`${colors.yellow}⚠️${colors.reset} ${msg}`),
+  server: (msg) => console.log(`${colors.cyan}🌐${colors.reset} ${msg}`),
+  watch: (msg) => console.log(`${colors.magenta}👀${colors.reset} ${msg}`),
+};
+
+class AutoDev {
+  constructor() {
+    this.processes = new Map();
+    this.isShuttingDown = false;
+  }
+
+  async checkDependencies() {
+    log.info("Checking dependencies...");
+
+    const requiredPackages = ["nodemon", "concurrently", "express", "cors"];
+    const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
+
+    const missing = requiredPackages.filter(
+      (pkg) =>
+        !packageJson.dependencies?.[pkg] && !packageJson.devDependencies?.[pkg]
+    );
+
+    if (missing.length > 0) {
+      log.error(`Missing packages: ${missing.join(", ")}`);
+      log.info("Installing missing packages...");
+      await this.runCommand("npm", ["install", ...missing, "--save-dev"]);
+    }
+
+    log.success("All dependencies are installed");
+  }
+
+  async runCommand(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, args, {
+        stdio: "inherit",
+        shell: true,
+        ...options,
+      });
+
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Command failed with code ${code}`));
+        }
+      });
+
+      child.on("error", reject);
+    });
+  }
+  async initialBuild() {
+    log.info("Running initial build...");
+    try {
+      await this.runCommand("node", ["build-simple.js"]);
+      log.success("Initial build completed");
+    } catch (error) {
+      log.error("Initial build failed:", error.message);
+      throw error;
+    }
+  }
+
+  startWatcher() {
+    log.watch("Starting file watcher...");
+
+    const watcher = spawn("npx", ["nodemon"], {
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: true,
+      env: { ...process.env, NODE_ENV: "development" },
+    });
+
+    watcher.stdout.on("data", (data) => {
+      const output = data.toString().trim();
+      if (output) {
+        console.log(`${colors.magenta}[WATCH]${colors.reset} ${output}`);
+      }
+    });
+
+    watcher.stderr.on("data", (data) => {
+      const output = data.toString().trim();
+      if (output) {
+        console.log(`${colors.yellow}[WATCH]${colors.reset} ${output}`);
+      }
+    });
+
+    watcher.on("close", (code) => {
+      if (!this.isShuttingDown) {
+        log.error(`Watcher exited with code ${code}`);
+      }
+    });
+
+    this.processes.set("watcher", watcher);
+    return watcher;
+  }
+
+  startDevServer() {
+    log.server("Starting development server...");
+
+    const server = spawn("node", ["dev-server.js"], {
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: true,
+    });
+
+    server.stdout.on("data", (data) => {
+      const output = data.toString().trim();
+      if (output) {
+        console.log(`${colors.cyan}[SERVER]${colors.reset} ${output}`);
+      }
+    });
+
+    server.stderr.on("data", (data) => {
+      const output = data.toString().trim();
+      if (output) {
+        console.log(`${colors.red}[SERVER]${colors.reset} ${output}`);
+      }
+    });
+
+    server.on("close", (code) => {
+      if (!this.isShuttingDown) {
+        log.error(`Server exited with code ${code}`);
+      }
+    });
+
+    this.processes.set("server", server);
+    return server;
+  }
+
+  setupSignalHandlers() {
+    const cleanup = () => {
+      if (this.isShuttingDown) return;
+      this.isShuttingDown = true;
+
+      console.log("\n");
+      log.info("Shutting down auto-dev environment...");
+
+      for (const [name, process] of this.processes) {
+        log.info(`Stopping ${name}...`);
+        process.kill("SIGTERM");
+      }
+
+      setTimeout(() => {
+        log.success("Auto-dev environment stopped");
+        process.exit(0);
+      }, 1000);
+    };
+
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  }
+
+  async start() {
+    console.log(`
+${colors.bright}🚀 Vega Providers Auto-Development Environment${colors.reset}
+
+${colors.cyan}Features:${colors.reset}
+• 👀 Auto-watch TypeScript files in /providers
+• 🔨 Auto-rebuild on file changes
+• 🌐 Development server with hot-reload
+• 📊 Real-time build feedback
+
+${colors.yellow}Press Ctrl+C to stop${colors.reset}
+`);
+
+    try {
+      // Setup signal handlers
+      this.setupSignalHandlers();
+
+      // Check dependencies
+      await this.checkDependencies();
+
+      // Initial build
+      await this.initialBuild();
+
+      // Start watcher and server
+      this.startWatcher();
+
+      // Wait a bit before starting server
+      setTimeout(() => {
+        this.startDevServer();
+      }, 2000);
+
+      log.success("Auto-development environment is running!");
+      log.info(
+        "Make changes to your providers and watch them rebuild automatically"
+      );
+    } catch (error) {
+      log.error("Failed to start auto-dev environment:", error.message);
+      process.exit(1);
+    }
+  }
+}
+
+// CLI interface
+if (require.main === module) {
+  const autoDev = new AutoDev();
+  autoDev.start();
+}
+
+module.exports = AutoDev;