bm2 1.0.3 → 1.0.5

package/src/index.ts

@@ -2,11 +2,21 @@
 /**
  * BM2 — Bun Process Manager
  * A production-grade process manager for Bun.
+ *
+ * Features:
+ * - Fork & cluster execution modes
+ * - Auto-restart & crash recovery
+ * - Health checks & monitoring
+ * - Log management & rotation
+ * - Deployment support
+ *
+ * https://github.com/your-org/bm2
+ * License: GPL-3.0-only
+ * Author: Zak <zak@maxxpainn.com>
  */
 
-import { existsSync, readFileSync, unlinkSync, openSync } from "fs";
+import { existsSync, readFileSync, unlinkSync } from "fs";
 import { resolve, join, extname } from "path";
-import { createConnection } from "net";
 import {
   APP_NAME,
   VERSION,
@@ -15,12 +25,15 @@ import {
   BM2_HOME,
   DASHBOARD_PORT,
   METRICS_PORT,
+  DAEMON_OUT_LOG_FILE,
 } from "./constants";
 import { ensureDirs, formatBytes, formatUptime, colorize, padRight } from "./utils";
 import { DeployManager } from "./deploy";
 import { StartupManager } from "./startup-manager";
 import { EnvManager } from "./env-manager";
 import type {
+  DaemonMessage,
+  DaemonResponse,
   StartOptions,
   EcosystemConfig,
   ProcessState,
@@ -32,34 +45,13 @@ import type {
 ensureDirs();
 
 // ---------------------------------------------------------------------------
-// Helpers
+// Daemon communication helpers
 // ---------------------------------------------------------------------------
 
-/**
- * Reads the last N lines from the daemon error log to help debug crashes.
- */
-function getDaemonErrorLog(linesToRead = 10): string {
-  const logPath = join(BM2_HOME, "daemon.err.log");
-  if (!existsSync(logPath)) return "";
-  try {
-    const content = readFileSync(logPath, "utf-8").trim();
-    if (!content) return "";
-    const lines = content.split("\n");
-    return lines.slice(-linesToRead).join("\n");
-  } catch {
-    return "";
-  }
-}
-
-/**
- * Check if the daemon process is actually running by reading the PID file
- * and sending signal 0 to verify the process exists.
- */
 function isDaemonRunning(): boolean {
   if (!existsSync(DAEMON_PID_FILE)) return false;
   try {
     const pid = parseInt(readFileSync(DAEMON_PID_FILE, "utf-8").trim());
-    if (isNaN(pid)) return false;
     process.kill(pid, 0); // signal 0 — just check existence
     return true;
   } catch {
@@ -67,182 +59,71 @@ function isDaemonRunning(): boolean {
   }
 }
 
-/**
- * Remove stale socket and PID files left behind by a crashed daemon.
- */
-function cleanupStaleFiles(): void {
-  try {
-    if (existsSync(DAEMON_SOCKET)) unlinkSync(DAEMON_SOCKET);
-  } catch { /* ignore */ }
-  try {
-    if (existsSync(DAEMON_PID_FILE)) unlinkSync(DAEMON_PID_FILE);
-  } catch { /* ignore */ }
-}
-
-/**
- * Start the daemon process if it is not already running.
- * Redirects daemon stdout/stderr to ~/.bm2/daemon.{out|err}.log
- */
 async function startDaemon(): Promise<void> {
-  if (isDaemonRunning()) {
-    // Daemon is alive. Check for socket.
-    if (existsSync(DAEMON_SOCKET)) return;
-
-    // Socket missing but process alive — wait briefly
-    for (let i = 0; i < 20; i++) {
-      if (existsSync(DAEMON_SOCKET)) return;
-      await Bun.sleep(100);
-    }
-
-    // Still no socket — kill stale process
-    try {
-      const pid = parseInt(readFileSync(DAEMON_PID_FILE, "utf-8").trim());
-      process.kill(pid, "SIGTERM");
-    } catch { /* ignore */ }
-    await Bun.sleep(500);
-  }
-
-  cleanupStaleFiles();
+  if (isDaemonRunning()) return;
 
   const daemonScript = join(import.meta.dir, "daemon.ts");
   const bunPath = Bun.which("bun") || "bun";
 
-  if (!existsSync(daemonScript)) {
-    throw new Error(`Daemon script not found at: ${daemonScript}`);
-  }
-
-  // Prepare log files for the daemon so we can see why it crashes
-  const outLog = join(BM2_HOME, "daemon.out.log");
-  const errLog = join(BM2_HOME, "daemon.err.log");
-  
-  // Open file descriptors (append mode)
-  const outFd = openSync(outLog, "a");
-  const errFd = openSync(errLog, "a");
-
-  // Spawn detached
   const child = Bun.spawn([bunPath, "run", daemonScript], {
-    stdin: "ignore",
-    stdout: outFd,
-    stderr: errFd,
-    detached: true,
+    stdout: Bun.file(DAEMON_OUT_LOG_FILE),
+    stderr: Bun.file(DAEMON_OUT_LOG_FILE),
+    stdin:  "ignore",
   });
 
+  // Detach so the daemon outlives the CLI
   child.unref();
 
-  // Wait for socket
-  const maxRetries = 50; // 5 seconds
-  for (let i = 0; i < maxRetries; i++) {
+  // Wait for socket to appear
+  for (let i = 0; i < 50; i++) {
     if (existsSync(DAEMON_SOCKET)) return;
     await Bun.sleep(100);
   }
 
-  // If we timed out, read the error log to show the user
-  const recentErrors = getDaemonErrorLog();
-  throw new Error(
-    "Daemon failed to start (socket not found).\n" +
-    (recentErrors 
-      ? `\n--- Daemon Stderr (last 10 lines) ---\n${recentErrors}\n-------------------------------------`
-      : `Check logs at: ${errLog}`)
-  );
+  throw new Error("Daemon failed to start (socket not found after 5 s)");
 }
 
-/**
- * Send a JSON message to the daemon and wait for a response.
- */
-async function sendToDaemon(message: object): Promise<any> {
-  await startDaemon();
-
-  return new Promise((resolve, reject) => {
-    let settled = false;
-
-    function settle(fn: typeof resolve | typeof reject, value: any) {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      fn(value);
-    }
-
-    // Timeout (10s)
-    const timeout = setTimeout(() => {
-      settle(reject, new Error("Daemon response timed out"));
-      try { socket.destroy(); } catch { /* ignore */ }
-    }, 10_000);
-
-    const socket = createConnection(DAEMON_SOCKET, () => {
-      socket.write(JSON.stringify(message) + "\n");
-    });
-
-    let data = "";
-
-    socket.on("data", (chunk) => {
-      data += chunk.toString();
-      const lines = data.split("\n").filter((l) => l.trim());
-      for (const line of lines) {
-        try {
-          const parsed = JSON.parse(line);
-          socket.end();
-          settle(resolve, parsed);
-          return;
-        } catch {
-          // Partial JSON, wait for more
-        }
-      }
-    });
-
-    socket.on("close", () => {
-      if (!settled) {
-        // Try to parse partial data
-        if (data.trim()) {
-          try {
-            const parsed = JSON.parse(data);
-            settle(resolve, parsed);
-            return;
-          } catch { /* ignore */ }
-        }
-
-        // Check if daemon logged an error before dying
-        const recentErrors = getDaemonErrorLog(5);
-        const errorDetails = recentErrors 
-          ? `\n\nDaemon Error Log:\n${colorize(recentErrors, "red")}`
-          : `\nCheck logs at: ${join(BM2_HOME, "daemon.err.log")}`;
-
-        settle(
-          reject,
-          new Error(
-            "Daemon connection closed unexpectedly. The daemon likely crashed while processing your command." + 
-            errorDetails
-          )
-        );
-      }
-    });
-
-    socket.on("error", (err: NodeJS.ErrnoException) => {
-      if (err.code === "ECONNREFUSED" || err.code === "ENOENT") {
-        cleanupStaleFiles();
-        settle(
-          reject,
-          new Error("Daemon is unreachable (stale socket). Please run the command again to restart it.")
-        );
-      } else {
-        settle(reject, err);
-      }
+async function sendToDaemon(msg: DaemonMessage): Promise<DaemonResponse> {
+    
+    await startDaemon();
+  
+    const res = await fetch("http://localhost/command", {
+        unix: DAEMON_SOCKET,
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(msg),
     });
-  });
+    
+    if (!res.ok) {
+        throw new Error(`Daemon error: ${res.status}`);
+    }
+    
+    const resJson: DaemonResponse = await res.json() as DaemonResponse;
+    
+    return resJson;
 }
 
 // ---------------------------------------------------------------------------
-// Table Rendering & Utilities
+// Table rendering
 // ---------------------------------------------------------------------------
 
 function statusColor(status: string): string {
   switch (status) {
-    case "online": return "green";
-    case "stopped": return "gray";
-    case "errored": return "red";
+    case "online":
+      return "green";
+    case "stopped":
+      return "gray";
+    case "errored":
+      return "red";
     case "launching":
-    case "waiting-restart": return "yellow";
-    case "stopping": return "magenta";
-    default: return "white";
+    case "waiting-restart":
+      return "yellow";
+    case "stopping":
+      return "magenta";
+    default:
+      return "white";
   }
 }
 
@@ -256,7 +137,7 @@ function printProcessTable(processes: ProcessState[]) {
     padRight("id", 4),
     padRight("name", 20),
     padRight("namespace", 12),
-    padRight("ver", 8),
+    padRight("version", 10),
     padRight("mode", 8),
     padRight("pid", 8),
     padRight("uptime", 10),
@@ -270,12 +151,14 @@ function printProcessTable(processes: ProcessState[]) {
   console.log(colorize("─".repeat(header.length), "dim"));
 
   for (const p of processes) {
-    const uptime = p.status === "online" ? formatUptime(Date.now() - p.pm2_env.pm_uptime) : "0s";
+    const uptime =
+      p.status === "online" ? formatUptime(Date.now() - p.pm2_env.pm_uptime) : "0s";
+
     const row = [
       padRight(String(p.pm_id), 4),
       padRight(p.name, 20),
       padRight(p.namespace || "default", 12),
-      padRight(p.pm2_env.version || "N/A", 8),
+      padRight(p.pm2_env.version || "N/A", 10),
       padRight(p.pm2_env.execMode, 8),
       padRight(p.pid ? String(p.pid) : "N/A", 8),
       padRight(uptime, 10),
@@ -284,71 +167,187 @@ function printProcessTable(processes: ProcessState[]) {
       padRight(p.monit.cpu.toFixed(1) + "%", 8),
       padRight(formatBytes(p.monit.memory), 10),
     ];
-    console.log(row.join(" ").replace(p.status, colorize(p.status, statusColor(p.status))));
+
+    const line = row.join(" ");
+    // Colorize the status cell inline
+    const colored = line.replace(
+      p.status,
+      colorize(p.status, statusColor(p.status))
+    );
+    console.log(colored);
   }
 }
 
+// ---------------------------------------------------------------------------
+// Ecosystem config loader
+// ---------------------------------------------------------------------------
+
 async function loadEcosystemConfig(filePath: string): Promise<EcosystemConfig> {
   const abs = resolve(filePath);
-  if (!existsSync(abs)) throw new Error(`Ecosystem file not found: ${abs}`);
+  if (!existsSync(abs)) {
+    throw new Error(`Ecosystem file not found: ${abs}`);
+  }
+
   const ext = extname(abs);
-  if (ext === ".json") return await Bun.file(abs).json();
+  if (ext === ".json") {
+    return await Bun.file(abs).json();
+  }
+
+  // .ts, .js, .mjs — dynamic import
   const mod = await import(abs);
   return mod.default || mod;
 }
 
+// ---------------------------------------------------------------------------
+// Parse CLI flags into StartOptions
+// ---------------------------------------------------------------------------
+
 function parseStartFlags(args: string[], scriptOrConfig: string): StartOptions {
   const opts: StartOptions = { script: scriptOrConfig };
+
   let i = 0;
   const positionalArgs: string[] = [];
 
   while (i < args.length) {
     const arg = args[i]!;
+
     switch (arg) {
-      case "--name": case "-n": opts.name = args[++i]; break;
-      case "--instances": case "-i": opts.instances = parseInt(args[++i]!) || 1; break;
-      case "--cwd": opts.cwd = args[++i]; break;
-      case "--interpreter": opts.interpreter = args[++i]; break;
-      case "--interpreter-args": opts.interpreterArgs = args[++i]!.split(" "); break;
-      case "--node-args": opts.nodeArgs = args[++i]!.split(" "); break;
-      case "--watch": case "-w": opts.watch = true; break;
-      case "--watch-path": 
+      case "--name":
+      case "-n":
+        opts.name = args[++i];
+        break;
+      case "--instances":
+      case "-i":
+        opts.instances = parseInt(args[++i]!) || 1;
+        break;
+      case "--cwd":
+        opts.cwd = args[++i];
+        break;
+      case "--interpreter":
+        opts.interpreter = args[++i];
+        break;
+      case "--interpreter-args":
+        opts.interpreterArgs = args[++i]!.split(" ");
+        break;
+      case "--node-args":
+        opts.nodeArgs = args[++i]!.split(" ");
+        break;
+      case "--watch":
+      case "-w":
+        opts.watch = true;
+        break;
+      case "--watch-path":
         if (!Array.isArray(opts.watch)) opts.watch = [];
-        (opts.watch as string[]).push(args[++i]!); 
-        break;
-      case "--ignore-watch": opts.ignoreWatch = args[++i]!.split(","); break;
-      case "--exec-mode": case "-x": opts.execMode = args[++i] as "fork" | "cluster"; break;
-      case "--max-memory-restart": opts.maxMemoryRestart = args[++i]; break;
-      case "--max-restarts": opts.maxRestarts = parseInt(args[++i]!); break;
-      case "--min-uptime": opts.minUptime = parseInt(args[++i]!); break;
-      case "--kill-timeout": opts.killTimeout = parseInt(args[++i]!); break;
-      case "--restart-delay": opts.restartDelay = parseInt(args[++i]!); break;
-      case "--cron": case "--cron-restart": opts.cron = args[++i]; break;
-      case "--no-autorestart": opts.autorestart = false; break;
+        (opts.watch as string[]).push(args[++i]!);
+        break;
+      case "--ignore-watch":
+        opts.ignoreWatch = args[++i]!.split(",");
+        break;
+      case "--exec-mode":
+      case "-x":
+        opts.execMode = args[++i] as "fork" | "cluster";
+        break;
+      case "--max-memory-restart":
+        opts.maxMemoryRestart = args[++i];
+        break;
+      case "--max-restarts":
+        opts.maxRestarts = parseInt(args[++i]!);
+        break;
+      case "--min-uptime":
+        opts.minUptime = parseInt(args[++i]!);
+        break;
+      case "--kill-timeout":
+        opts.killTimeout = parseInt(args[++i]!);
+        break;
+      case "--restart-delay":
+        opts.restartDelay = parseInt(args[++i]!);
+        break;
+      case "--cron":
+      case "--cron-restart":
+        opts.cron = args[++i];
+        break;
+      case "--no-autorestart":
+        opts.autorestart = false;
+        break;
       case "--env": {
-        const p = args[++i]!;
-        const idx = p.indexOf("=");
-        if (idx !== -1) {
+        const envPair = args[++i]!;
+        const eqIdx = envPair.indexOf("=");
+        if (eqIdx !== -1) {
           if (!opts.env) opts.env = {};
-          opts.env[p.substring(0, idx)] = p.substring(idx + 1);
+          opts.env[envPair.substring(0, eqIdx)] = envPair.substring(eqIdx + 1);
         }
         break;
       }
-      case "--log": case "--output": case "-o": opts.outFile = args[++i]; break;
-      case "--error": case "-e": opts.errorFile = args[++i]; break;
-      case "--merge-logs": opts.mergeLogs = true; break;
-      case "--log-date-format": opts.logDateFormat = args[++i]; break;
-      case "--log-max-size": opts.logMaxSize = args[++i]; break;
-      case "--log-retain": opts.logRetain = parseInt(args[++i]!); break;
-      case "--log-compress": opts.logCompress = true; break;
-      case "--port": case "-p": opts.port = parseInt(args[++i]!); break;
-      case "--namespace": opts.namespace = args[++i]; break;
-      case "--": positionalArgs.push(...args.slice(i + 1)); i = args.length; break;
-      default: if (!arg.startsWith("-")) positionalArgs.push(arg); break;
+      case "--log":
+      case "--output":
+      case "-o":
+        opts.outFile = args[++i];
+        break;
+      case "--error":
+      case "-e":
+        opts.errorFile = args[++i];
+        break;
+      case "--merge-logs":
+        opts.mergeLogs = true;
+        break;
+      case "--log-date-format":
+        opts.logDateFormat = args[++i];
+        break;
+      case "--log-max-size":
+        opts.logMaxSize = args[++i];
+        break;
+      case "--log-retain":
+        opts.logRetain = parseInt(args[++i]!);
+        break;
+      case "--log-compress":
+        opts.logCompress = true;
+        break;
+      case "--port":
+      case "-p":
+        opts.port = parseInt(args[++i]!);
+        break;
+      case "--health-check-url":
+        opts.healthCheckUrl = args[++i];
+        break;
+      case "--health-check-interval":
+        opts.healthCheckInterval = parseInt(args[++i]!);
+        break;
+      case "--health-check-timeout":
+        opts.healthCheckTimeout = parseInt(args[++i]!);
+        break;
+      case "--health-check-max-fails":
+        opts.healthCheckMaxFails = parseInt(args[++i]!);
+        break;
+      case "--wait-ready":
+        opts.waitReady = true;
+        break;
+      case "--listen-timeout":
+        opts.listenTimeout = parseInt(args[++i]!);
+        break;
+      case "--namespace":
+        opts.namespace = args[++i];
+        break;
+      case "--source-map-support":
+        opts.sourceMapSupport = true;
+        break;
+      case "--":
+        // Everything after -- is passed as script args
+        positionalArgs.push(...args.slice(i + 1));
+        i = args.length;
+        break;
+      default:
+        if (!arg.startsWith("-")) {
+          positionalArgs.push(arg);
+        }
+        break;
     }
     i++;
   }
-  if (positionalArgs.length > 0) opts.args = positionalArgs;
+
+  if (positionalArgs.length > 0) {
+    opts.args = positionalArgs;
+  }
+
   return opts;
 }
 
@@ -363,14 +362,14 @@ async function cmdStart(args: string[]) {
     process.exit(1);
   }
 
-  // Check if file exists before sending to daemon
-  if (!existsSync(scriptOrConfig)) {
-    console.error(colorize(`Error: Script or config not found: ${scriptOrConfig}`, "red"));
-    process.exit(1);
-  }
-
   const ext = extname(scriptOrConfig);
-  if (ext === ".json" || scriptOrConfig.includes("ecosystem") || scriptOrConfig.includes("bm2.config")) {
+
+  // Ecosystem file
+  if (
+    ext === ".json" ||
+    scriptOrConfig.includes("ecosystem") ||
+    scriptOrConfig.includes("bm2.config")
+  ) {
     const config = await loadEcosystemConfig(scriptOrConfig);
     const res = await sendToDaemon({ type: "ecosystem", data: config });
     if (!res.success) {
@@ -381,6 +380,7 @@ async function cmdStart(args: string[]) {
     return;
   }
 
+  // Single script
   const opts = parseStartFlags(args.slice(1), resolve(scriptOrConfig));
   opts.script = resolve(scriptOrConfig);
 
@@ -395,7 +395,9 @@ async function cmdStart(args: string[]) {
 async function cmdStop(args: string[]) {
   const target = args[0] || "all";
   const type = target === "all" ? "stopAll" : "stop";
-  const res = await sendToDaemon({ type, data: target === "all" ? undefined : { target } });
+  const data = target === "all" ? undefined : { target };
+
+  const res = await sendToDaemon({ type, data });
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
@@ -406,7 +408,9 @@ async function cmdStop(args: string[]) {
 async function cmdRestart(args: string[]) {
   const target = args[0] || "all";
   const type = target === "all" ? "restartAll" : "restart";
-  const res = await sendToDaemon({ type, data: target === "all" ? undefined : { target } });
+  const data = target === "all" ? undefined : { target };
+
+  const res = await sendToDaemon({ type, data });
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
@@ -417,7 +421,9 @@ async function cmdRestart(args: string[]) {
 async function cmdReload(args: string[]) {
   const target = args[0] || "all";
   const type = target === "all" ? "reloadAll" : "reload";
-  const res = await sendToDaemon({ type, data: target === "all" ? undefined : { target } });
+  const data = target === "all" ? undefined : { target };
+
+  const res = await sendToDaemon({ type, data });
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
@@ -428,7 +434,9 @@ async function cmdReload(args: string[]) {
 async function cmdDelete(args: string[]) {
   const target = args[0] || "all";
   const type = target === "all" ? "deleteAll" : "delete";
-  const res = await sendToDaemon({ type, data: target === "all" ? undefined : { target } });
+  const data = target === "all" ? undefined : { target };
+
+  const res = await sendToDaemon({ type, data });
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
@@ -452,21 +460,50 @@ async function cmdDescribe(args: string[]) {
     console.error(colorize("Usage: bm2 describe <id|name>", "red"));
     process.exit(1);
   }
+
   const res = await sendToDaemon({ type: "describe", data: { target } });
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
   }
+
   const processes: ProcessState[] = res.data;
   for (const p of processes) {
     console.log(colorize(`\n─── ${p.name} (id: ${p.pm_id}) ───`, "bold"));
     console.log(`  Status       : ${colorize(p.status, statusColor(p.status))}`);
+    console.log(`  PID          : ${p.pid || "N/A"}`);
+    console.log(`  Exec mode    : ${p.pm2_env.execMode}`);
+    console.log(`  Instances    : ${p.pm2_env.instances}`);
+    console.log(`  Namespace    : ${p.namespace || "default"}`);
     console.log(`  Script       : ${p.pm2_env.script}`);
-    console.log(`  Log (out)    : ${p.pm2_env.pm_out_log_path}`);
-    console.log(`  Log (err)    : ${p.pm2_env.pm_err_log_path}`);
+    console.log(`  CWD          : ${p.pm2_env.cwd}`);
+    console.log(`  Args         : ${p.pm2_env.args.join(" ") || "(none)"}`);
+    console.log(`  Interpreter  : ${p.pm2_env.interpreter || "bun"}`);
     console.log(`  Restarts     : ${p.pm2_env.restart_time}`);
-    console.log(`  Memory       : ${formatBytes(p.monit.memory)}`);
+    console.log(`  Unstable     : ${p.pm2_env.unstable_restarts}`);
+    console.log(
+      `  Uptime       : ${
+        p.status === "online" ? formatUptime(Date.now() - p.pm2_env.pm_uptime) : "N/A"
+      }`
+    );
+    console.log(`  Created at   : ${new Date(p.pm2_env.created_at).toISOString()}`);
     console.log(`  CPU          : ${p.monit.cpu.toFixed(1)}%`);
+    console.log(`  Memory       : ${formatBytes(p.monit.memory)}`);
+    if (p.monit.handles !== undefined)
+      console.log(`  Handles      : ${p.monit.handles}`);
+    if (p.monit.eventLoopLatency !== undefined)
+      console.log(`  EL Latency   : ${p.monit.eventLoopLatency.toFixed(2)} ms`);
+    console.log(`  Watch        : ${p.pm2_env.watch}`);
+    console.log(`  Autorestart  : ${p.pm2_env.autorestart}`);
+    console.log(`  Max restarts : ${p.pm2_env.maxRestarts}`);
+    console.log(`  Kill timeout : ${p.pm2_env.killTimeout} ms`);
+    if (p.pm2_env.healthCheckUrl)
+      console.log(`  Health URL   : ${p.pm2_env.healthCheckUrl}`);
+    if (p.pm2_env.cronRestart)
+      console.log(`  Cron restart : ${p.pm2_env.cronRestart}`);
+    if (p.pm2_env.port)
+      console.log(`  Port         : ${p.pm2_env.port}`);
+    console.log();
   }
 }
 
@@ -474,17 +511,26 @@ async function cmdLogs(args: string[]) {
   const target = args[0] || "all";
   let lines = 20;
   const linesIdx = args.indexOf("--lines");
-  if (linesIdx !== -1 && args[linesIdx + 1]) lines = parseInt(args[linesIdx + 1]!);
-  
+  if (linesIdx !== -1 && args[linesIdx + 1]) {
+    lines = parseInt(args[linesIdx + 1]!);
+  }
+
   const res = await sendToDaemon({ type: "logs", data: { target, lines } });
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
   }
+
   for (const log of res.data) {
     console.log(colorize(`\n─── ${log.name} (id: ${log.id}) ───`, "bold"));
-    if (log.out) console.log(log.out);
-    if (log.err) console.log(colorize(log.err, "red"));
+    if (log.out) {
+      console.log(colorize("--- stdout ---", "dim"));
+      console.log(log.out);
+    }
+    if (log.err) {
+      console.log(colorize("--- stderr ---", "red"));
+      console.log(log.err);
+    }
   }
 }
 
@@ -505,6 +551,7 @@ async function cmdScale(args: string[]) {
     console.error(colorize("Usage: bm2 scale <name|id> <count>", "red"));
     process.exit(1);
   }
+
   const res = await sendToDaemon({ type: "scale", data: { target, count } });
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
@@ -531,13 +578,31 @@ async function cmdResurrect() {
   printProcessTable(res.data);
 }
 
-async function cmdKill() {
-  try {
-    await sendToDaemon({ type: "kill" });
-  } catch { /* ignore */ }
-  await Bun.sleep(500);
-  cleanupStaleFiles();
-  console.log(colorize("✓ Daemon killed", "green"));
+async function cmdSignal(args: string[]) {
+  const signal = args[0];
+  const target = args[1];
+  if (!signal || !target) {
+    console.error(colorize("Usage: bm2 sendSignal <signal> <id|name>", "red"));
+    process.exit(1);
+  }
+
+  const res = await sendToDaemon({ type: "signal", data: { target, signal } });
+  if (!res.success) {
+    console.error(colorize(`Error: ${res.error}`, "red"));
+    process.exit(1);
+  }
+  console.log(colorize(`✓ Signal ${signal} sent to ${target}`, "green"));
+}
+
+async function cmdReset(args: string[]) {
+  const target = args[0] || "all";
+  const res = await sendToDaemon({ type: "reset", data: { target } });
+  if (!res.success) {
+    console.error(colorize(`Error: ${res.error}`, "red"));
+    process.exit(1);
+  }
+  console.log(colorize("✓ Restart counters reset", "green"));
+  printProcessTable(res.data);
 }
 
 async function cmdMonit() {
@@ -546,42 +611,447 @@ async function cmdMonit() {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
   }
+
   const snapshot = res.data;
   console.log(colorize("\n⚡ BM2 Monitor\n", "bold"));
-  console.log(`System: CPU ${snapshot.system.cpuCount} cores | Load ${snapshot.system.loadAvg[0]?.toFixed(2)}`);
+
+  console.log(colorize("System:", "cyan"));
+  console.log(`  Platform : ${snapshot.system.platform}`);
+  console.log(`  CPUs     : ${snapshot.system.cpuCount}`);
+  console.log(`  Memory   : ${formatBytes(snapshot.system.totalMemory - snapshot.system.freeMemory)} / ${formatBytes(snapshot.system.totalMemory)}`);
+  console.log(`  Load avg : ${snapshot.system.loadAvg.map((l: number) => l.toFixed(2)).join(", ")}`);
+  console.log();
+
+  console.log(colorize("Processes:", "cyan"));
   for (const p of snapshot.processes) {
-    console.log(`${padRight(p.name, 20)} ${colorize(p.status, statusColor(p.status))} CPU: ${p.cpu.toFixed(1)}% Mem: ${formatBytes(p.memory)}`);
+    const statusStr = colorize(padRight(p.status, 14), statusColor(p.status));
+    console.log(
+      `  ${padRight(String(p.id), 4)} ${padRight(p.name, 20)} ${statusStr} CPU: ${padRight(p.cpu.toFixed(1) + "%", 8)} MEM: ${padRight(formatBytes(p.memory), 10)} ↺ ${p.restarts}`
+    );
+  }
+  console.log();
+}
+
+async function cmdDashboard(args: string[]) {
+  let port = DASHBOARD_PORT;
+  let metricsPort = METRICS_PORT;
+
+  const portIdx = args.indexOf("--port");
+  if (portIdx !== -1 && args[portIdx + 1]) port = parseInt(args[portIdx + 1]!);
+  const mIdx = args.indexOf("--metrics-port");
+  if (mIdx !== -1 && args[mIdx + 1]) metricsPort = parseInt(args[mIdx + 1]!);
+
+  const res = await sendToDaemon({ type: "dashboard", data: { port, metricsPort } });
+  if (!res.success) {
+    console.error(colorize(`Error: ${res.error}`, "red"));
+    process.exit(1);
+  }
+  console.log(colorize(`✓ Dashboard running at http://localhost:${res.data.port}`, "green"));
+  console.log(colorize(`  Prometheus metrics at http://localhost:${res.data.metricsPort}/metrics`, "dim"));
+}
+
+async function cmdDashboardStop() {
+  const res = await sendToDaemon({ type: "dashboardStop" });
+  if (!res.success) {
+    console.error(colorize(`Error: ${res.error}`, "red"));
+    process.exit(1);
+  }
+  console.log(colorize("✓ Dashboard stopped", "green"));
+}
+
+async function cmdPing() {
+  try {
+    const res = await sendToDaemon({ type: "ping" });
+    if (res.success) {
+      console.log(colorize("✓ Daemon is alive", "green"));
+      console.log(`  PID    : ${res.data.pid}`);
+      console.log(`  Uptime : ${formatUptime(res.data.uptime * 1000)}`);
+    } else {
+      console.log(colorize("✗ Daemon responded with error", "red"));
+    }
+  } catch {
+    console.log(colorize("✗ Daemon is not running", "red"));
+  }
+}
+
+async function cmdKill() {
+  try {
+    await sendToDaemon({ type: "kill" });
+  } catch {
+    // Expected — daemon exits
+  }
+
+  // Clean up leftover files
+  try {
+    if (existsSync(DAEMON_SOCKET)) unlinkSync(DAEMON_SOCKET);
+  } catch {}
+  try {
+    if (existsSync(DAEMON_PID_FILE)) unlinkSync(DAEMON_PID_FILE);
+  } catch {}
+
+  console.log(colorize("✓ Daemon killed", "green"));
+}
+
+async function cmdDeploy(args: string[]) {
+  const configFile = args[0];
+  const environment = args[1];
+
+  if (!configFile || !environment) {
+    console.error(colorize("Usage: bm2 deploy <config> <environment> [setup]", "red"));
+    process.exit(1);
+  }
+
+  const config = await loadEcosystemConfig(configFile);
+  if (!config.deploy || !config.deploy[environment]) {
+    console.error(colorize(`Deploy environment "${environment}" not found in config`, "red"));
+    process.exit(1);
+  }
+
+  const deployConfig = config.deploy[environment]!;
+  const deployer = new DeployManager();
+
+  if (args[2] === "setup") {
+    await deployer.setup(deployConfig);
+  } else {
+    await deployer.deploy(deployConfig, args[2]);
+  }
+}
+
+async function cmdStartup(args: string[]) {
+  const startup = new StartupManager();
+
+  if (args[0] === "remove" || args[0] === "uninstall") {
+    const result = await startup.uninstall();
+    console.log(result);
+    return;
+  }
+
+  if (args[0] === "install") {
+    const result = await startup.install();
+    console.log(result);
+    return;
   }
+
+  // Just print the config
+  const content = await startup.generate(args[0]);
+  console.log(content);
+}
+
+async function cmdEnv(args: string[]) {
+  const envMgr = new EnvManager();
+  const subCmd = args[0];
+
+  switch (subCmd) {
+    case "set": {
+      const name = args[1];
+      const key = args[2];
+      const value = args[3];
+      if (!name || !key || value === undefined) {
+        console.error(colorize("Usage: bm2 env set <name> <key> <value>", "red"));
+        process.exit(1);
+      }
+      await envMgr.setEnv(name, key, value);
+      console.log(colorize(`✓ Set ${key}=${value} for ${name}`, "green"));
+      break;
+    }
+    case "get": {
+      const name = args[1];
+      if (!name) {
+        console.error(colorize("Usage: bm2 env get <name>", "red"));
+        process.exit(1);
+      }
+      const env = await envMgr.getEnv(name);
+      for (const [k, v] of Object.entries(env)) {
+        console.log(`${colorize(k, "cyan")}=${v}`);
+      }
+      break;
+    }
+    case "delete":
+    case "rm": {
+      const name = args[1];
+      const key = args[2];
+      if (!name) {
+        console.error(colorize("Usage: bm2 env delete <name> [key]", "red"));
+        process.exit(1);
+      }
+      await envMgr.deleteEnv(name, key);
+      console.log(colorize(`✓ Deleted`, "green"));
+      break;
+    }
+    case "list": {
+      const all = await envMgr.getEnvs();
+      for (const [name, env] of Object.entries(all)) {
+        console.log(colorize(`\n${name}:`, "bold"));
+        for (const [k, v] of Object.entries(env)) {
+          console.log(`  ${colorize(k, "cyan")}=${v}`);
+        }
+      }
+      break;
+    }
+    default:
+      console.error(colorize("Usage: bm2 env <set|get|delete|list> ...", "red"));
+      process.exit(1);
+  }
+}
+
+async function cmdModule(args: string[]) {
+  const subCmd = args[0];
+
+  switch (subCmd) {
+    case "install": {
+      const mod = args[1];
+      if (!mod) {
+        console.error(colorize("Usage: bm2 module install <name|url|path>", "red"));
+        process.exit(1);
+      }
+      const res = await sendToDaemon({ type: "moduleInstall", data: { module: mod } });
+      if (!res.success) {
+        console.error(colorize(`Error: ${res.error}`, "red"));
+        process.exit(1);
+      }
+      console.log(colorize(`✓ Module installed at ${res.data.path}`, "green"));
+      break;
+    }
+    case "uninstall":
+    case "remove": {
+      const mod = args[1];
+      if (!mod) {
+        console.error(colorize("Usage: bm2 module uninstall <name>", "red"));
+        process.exit(1);
+      }
+      const res = await sendToDaemon({ type: "moduleUninstall", data: { module: mod } });
+      if (!res.success) {
+        console.error(colorize(`Error: ${res.error}`, "red"));
+        process.exit(1);
+      }
+      console.log(colorize("✓ Module uninstalled", "green"));
+      break;
+    }
+    case "list":
+    case "ls": {
+      const res = await sendToDaemon({ type: "moduleList" });
+      if (!res.success) {
+        console.error(colorize(`Error: ${res.error}`, "red"));
+        process.exit(1);
+      }
+      if (res.data.length === 0) {
+        console.log(colorize("No modules installed", "dim"));
+      } else {
+        for (const m of res.data) {
+          console.log(`  ${colorize(m.name, "cyan")} @ ${m.version}`);
+        }
+      }
+      break;
+    }
+    default:
+      console.error(colorize("Usage: bm2 module <install|uninstall|list> ...", "red"));
+      process.exit(1);
+  }
+}
+
+async function cmdPrometheus() {
+  const res = await sendToDaemon({ type: "prometheus" });
+  if (!res.success) {
+    console.error(colorize(`Error: ${res.error}`, "red"));
+    process.exit(1);
+  }
+  console.log(res.data);
 }
 
 // ---------------------------------------------------------------------------
-// Main Dispatch
+// Help
 // ---------------------------------------------------------------------------
 
-const args = process.argv.slice(2);
-const command = args[0];
-const commandArgs = args.slice(1);
-
-switch (command) {
-  case "start": await cmdStart(commandArgs); break;
-  case "stop": await cmdStop(commandArgs); break;
-  case "restart": await cmdRestart(commandArgs); break;
-  case "reload": await cmdReload(commandArgs); break;
-  case "delete": case "rm": await cmdDelete(commandArgs); break;
-  case "scale": await cmdScale(commandArgs); break;
-  case "list": case "ls": await cmdList(); break;
-  case "describe": await cmdDescribe(commandArgs); break;
-  case "logs": await cmdLogs(commandArgs); break;
-  case "flush": await cmdFlush(commandArgs); break;
-  case "monit": await cmdMonit(); break;
-  case "save": await cmdSave(); break;
-  case "resurrect": await cmdResurrect(); break;
-  case "kill": await cmdKill(); break;
-  case "help":
-  case undefined:
-    console.log(`BM2 v${VERSION} - Usage: bm2 <command> [options]`);
-    break;
-  default:
-    console.error(colorize(`Unknown command: ${command}`, "red"));
-    process.exit(1);
+function printHelp() {
+    console.log(`
+    ${colorize("⚡ BM2", "bold")} ${colorize(`v${VERSION}`, "dim")} — Bun Process Manager
+    
+    ${colorize("Usage:", "bold")} bm2 <command> [options]
+    
+    ${colorize("Process Management:", "cyan")}
+    start <script|config> [opts]  Start a process or ecosystem config
+    stop [id|name|all]            Stop process(es)
+    restart [id|name|all]         Restart process(es)
+    reload [id|name|all]          Graceful zero-downtime reload
+    delete [id|name|all]          Stop and remove process(es)
+    scale <id|name> <count>       Scale to N instances
+    list | ls | status            List all processes
+    describe <id|name>            Show detailed process info
+    reset <id|name|all>           Reset restart counters
+    
+    ${colorize("Logs:", "cyan")}
+    logs [id|name|all] [--lines N]  Show recent logs
+    flush [id|name]                 Clear log files
+    
+    ${colorize("Monitoring:", "cyan")}
+    monit                         Show live metrics snapshot
+    dashboard [--port N]          Start web dashboard
+    dashboard stop                Stop web dashboard
+    prometheus                    Print Prometheus metrics
+    
+    ${colorize("Persistence:", "cyan")}
+    save                          Save current process list
+    resurrect                     Restore saved process list
+    startup [install|remove]      Generate/install startup script
+    
+    ${colorize("Deploy:", "cyan")}
+    deploy <config> <env> [setup] Deploy using ecosystem config
+    
+    ${colorize("Environment:", "cyan")}
+    env set <name> <key> <val>    Set env variable
+    env get <name>                List env vars for a process
+    env delete <name> [key]       Delete env variable(s)
+    env list                      List all env registries
+    
+    ${colorize("Modules:", "cyan")}
+    module install <name|url>     Install a BM2 module
+    module uninstall <name>       Remove a module
+    module list                   List installed modules
+    
+    ${colorize("Daemon:", "cyan")}
+    ping                          Check if daemon is alive
+    kill                          Kill the daemon and all processes
+    sendSignal <sig> <id|name>    Send OS signal to process
+    
+    ${colorize("Start Options:", "dim")}
+    --name, -n <name>             Process name
+    --instances, -i <N>           Number of instances (cluster)
+    --exec-mode, -x <mode>       fork or cluster
+    --watch, -w                   Watch for file changes
+    --cwd <path>                  Working directory
+    --interpreter <bin>           Custom interpreter
+    --node-args <args>            Extra runtime arguments
+    --max-memory-restart <size>   e.g. 200M, 1G
+    --max-restarts <N>            Max restart attempts
+    --cron, --cron-restart <expr> Cron-based restart schedule
+    --port, -p <port>             Base port for cluster
+    --env <KEY=VALUE>             Set environment variable
+    --no-autorestart              Disable auto-restart
+    --log, -o <file>              Custom stdout log path
+    --error, -e <file>            Custom stderr log path
+    --namespace <ns>              Namespace grouping
+    --wait-ready                  Wait for ready signal
+    --health-check-url <url>      HTTP health check endpoint
+    -- <args...>                  Pass arguments to script
+    
+    ${colorize("Examples:", "dim")}
+    bm2 start app.ts
+    bm2 start server.ts --name api -i 4 --watch
+    bm2 start ecosystem.config.ts
+    bm2 restart api
+    bm2 scale api 8
+    bm2 logs api --lines 100
+    bm2 monit
+    bm2 save && bm2 resurrect
+    `);
+    }
+    
+    // ---------------------------------------------------------------------------
+    // Main dispatch
+    // ---------------------------------------------------------------------------
+    
+    const args = process.argv.slice(2);
+    const command = args[0];
+    const commandArgs = args.slice(1);
+    
+    switch (command) {
+    case "start":
+        await cmdStart(commandArgs);
+        break;
+    case "stop":
+        await cmdStop(commandArgs);
+        break;
+    case "restart":
+        await cmdRestart(commandArgs);
+        break;
+    case "reload":
+        await cmdReload(commandArgs);
+        break;
+    case "delete":
+    case "del":
+    case "rm":
+        await cmdDelete(commandArgs);
+        break;
+    case "scale":
+        await cmdScale(commandArgs);
+        break;
+    case "list":
+    case "ls":
+    case "status":
+        await cmdList();
+        break;
+    case "describe":
+    case "show":
+    case "info":
+        await cmdDescribe(commandArgs);
+        break;
+    case "logs":
+    case "log":
+        await cmdLogs(commandArgs);
+        break;
+    case "flush":
+        await cmdFlush(commandArgs);
+        break;
+    case "monit":
+    case "monitor":
+        await cmdMonit();
+        break;
+    case "dashboard":
+        if (commandArgs[0] === "stop") {
+        await cmdDashboardStop();
+        } else {
+        await cmdDashboard(commandArgs);
+        }
+        break;
+    case "prometheus":
+        await cmdPrometheus();
+        break;
+    case "save":
+    case "dump":
+        await cmdSave();
+        break;
+    case "resurrect":
+    case "restore":
+        await cmdResurrect();
+        break;
+    case "reset":
+        await cmdReset(commandArgs);
+        break;
+    case "sendSignal":
+    case "signal":
+        await cmdSignal(commandArgs);
+        break;
+    case "ping":
+        await cmdPing();
+        break;
+    case "kill":
+        await cmdKill();
+        break;
+    case "deploy":
+        await cmdDeploy(commandArgs);
+        break;
+    case "startup":
+        await cmdStartup(commandArgs);
+        break;
+    case "env":
+        await cmdEnv(commandArgs);
+        break;
+    case "module":
+        await cmdModule(commandArgs);
+        break;
+    case "version":
+    case "-v":
+    case "--version":
+        console.log(`${APP_NAME} v${VERSION}`);
+        break;
+    case "help":
+    case "-h":
+    case "--help":
+    case undefined:
+        printHelp();
+        break;
+    default:
+        console.error(colorize(`Unknown command: ${command}`, "red"));
+        console.error(`Run ${colorize("bm2 --help", "cyan")} for usage information.`);
+        process.exit(1);
 }