bm2 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bm2",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "A blazing-fast, full-featured process manager built entirely on Bun native APIs. The modern PM2 replacement — zero Node.js dependencies, pure Bun performance.",
   "main": "src/index.ts",
   "module": "src/index.ts",
@@ -59,9 +59,12 @@
     "linux",
     "darwin"
   ],
-  "dependencies": {},
+  "dependencies": {
+    "ws": "^8.19.0"
+  },
   "devDependencies": {
     "@types/bun": "^1.3.9",
+    "@types/ws": "^8.18.1",
     "bun-types": "latest",
     "typescript": "^5.9.3"
   }

package/src/hello.js

@@ -0,0 +1,2 @@
+
+console.log("Hello ===>")

package/src/index.ts

@@ -2,21 +2,11 @@
 /**
  * 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 } from "fs";
+import { existsSync, readFileSync, unlinkSync, openSync } from "fs";
 import { resolve, join, extname } from "path";
+import { createConnection } from "net";
 import {
   APP_NAME,
   VERSION,
@@ -31,8 +21,6 @@ import { DeployManager } from "./deploy";
 import { StartupManager } from "./startup-manager";
 import { EnvManager } from "./env-manager";
 import type {
-  DaemonMessage,
-  DaemonResponse,
   StartOptions,
   EcosystemConfig,
   ProcessState,
@@ -44,13 +32,34 @@ import type {
 ensureDirs();
 
 // ---------------------------------------------------------------------------
-// Daemon communication helpers
+// 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 {
@@ -58,92 +67,182 @@ 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()) return;
+  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();
 
   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], {
-    stdout: "ignore",
-    stderr: "ignore",
     stdin: "ignore",
+    stdout: outFd,
+    stderr: errFd,
+    detached: true,
   });
 
-  // Detach so the daemon outlives the CLI
   child.unref();
 
-  // Wait for socket to appear
-  for (let i = 0; i < 50; i++) {
+  // Wait for socket
+  const maxRetries = 50; // 5 seconds
+  for (let i = 0; i < maxRetries; i++) {
     if (existsSync(DAEMON_SOCKET)) return;
     await Bun.sleep(100);
   }
 
-  throw new Error("Daemon failed to start (socket not found after 5 s)");
+  // 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}`)
+  );
 }
 
-async function sendToDaemon(msg: DaemonMessage): Promise<DaemonResponse> {
+/**
+ * Send a JSON message to the daemon and wait for a response.
+ */
+async function sendToDaemon(message: object): Promise<any> {
   await startDaemon();
 
-  return new Promise((resolvePromise, reject) => {
-    const id = crypto.randomUUID();
-    msg.id = id;
+  return new Promise((resolve, reject) => {
+    let settled = false;
 
-    const timeout = setTimeout(() => {
-      reject(new Error("Daemon response timed out"));
-    }, 30_000);
-
-    const ws = new WebSocket(`ws+unix://${DAEMON_SOCKET}`);
-
-    ws.onopen = () => {
-      ws.send(JSON.stringify(msg));
-    };
+    function settle(fn: typeof resolve | typeof reject, value: any) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      fn(value);
+    }
 
-    ws.onmessage = (event) => {
-      try {
-        const res: DaemonResponse = JSON.parse(String(event.data));
-        if (res.id === id || !res.id) {
-          clearTimeout(timeout);
-          ws.close();
-          resolvePromise(res);
+    // 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
         }
-      } catch (err: any) {
-        clearTimeout(timeout);
-        ws.close();
-        reject(err);
       }
-    };
-
-    ws.onerror = (err) => {
-      clearTimeout(timeout);
-      reject(new Error(`WebSocket error: ${err}`));
-    };
+    });
+
+    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 */ }
+        }
 
-    ws.onclose = () => {
-      clearTimeout(timeout);
-    };
+        // 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);
+      }
+    });
   });
 }
 
 // ---------------------------------------------------------------------------
-// Table rendering
+// Table Rendering & Utilities
 // ---------------------------------------------------------------------------
 
 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";
   }
 }
 
@@ -157,7 +256,7 @@ function printProcessTable(processes: ProcessState[]) {
     padRight("id", 4),
     padRight("name", 20),
     padRight("namespace", 12),
-    padRight("version", 10),
+    padRight("ver", 8),
     padRight("mode", 8),
     padRight("pid", 8),
     padRight("uptime", 10),
@@ -171,14 +270,12 @@ 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", 10),
+      padRight(p.pm2_env.version || "N/A", 8),
       padRight(p.pm2_env.execMode, 8),
       padRight(p.pid ? String(p.pid) : "N/A", 8),
       padRight(uptime, 10),
@@ -187,187 +284,71 @@ function printProcessTable(processes: ProcessState[]) {
       padRight(p.monit.cpu.toFixed(1) + "%", 8),
       padRight(formatBytes(p.monit.memory), 10),
     ];
-
-    const line = row.join(" ");
-    // Colorize the status cell inline
-    const colored = line.replace(
-      p.status,
-      colorize(p.status, statusColor(p.status))
-    );
-    console.log(colored);
+    console.log(row.join(" ").replace(p.status, colorize(p.status, statusColor(p.status))));
   }
 }
 
-// ---------------------------------------------------------------------------
-// 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();
-  }
-
-  // .ts, .js, .mjs — dynamic import
+  if (ext === ".json") return await Bun.file(abs).json();
   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 envPair = args[++i]!;
-        const eqIdx = envPair.indexOf("=");
-        if (eqIdx !== -1) {
+        const p = args[++i]!;
+        const idx = p.indexOf("=");
+        if (idx !== -1) {
           if (!opts.env) opts.env = {};
-          opts.env[envPair.substring(0, eqIdx)] = envPair.substring(eqIdx + 1);
+          opts.env[p.substring(0, idx)] = p.substring(idx + 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 "--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;
+      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;
     }
     i++;
   }
-
-  if (positionalArgs.length > 0) {
-    opts.args = positionalArgs;
-  }
-
+  if (positionalArgs.length > 0) opts.args = positionalArgs;
   return opts;
 }
 
@@ -382,14 +363,14 @@ async function cmdStart(args: string[]) {
     process.exit(1);
   }
 
-  const ext = extname(scriptOrConfig);
+  // 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);
+  }
 
-  // Ecosystem file
-  if (
-    ext === ".json" ||
-    scriptOrConfig.includes("ecosystem") ||
-    scriptOrConfig.includes("bm2.config")
-  ) {
+  const ext = extname(scriptOrConfig);
+  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) {
@@ -400,7 +381,6 @@ async function cmdStart(args: string[]) {
     return;
   }
 
-  // Single script
   const opts = parseStartFlags(args.slice(1), resolve(scriptOrConfig));
   opts.script = resolve(scriptOrConfig);
 
@@ -415,9 +395,7 @@ async function cmdStart(args: string[]) {
 async function cmdStop(args: string[]) {
   const target = args[0] || "all";
   const type = target === "all" ? "stopAll" : "stop";
-  const data = target === "all" ? undefined : { target };
-
-  const res = await sendToDaemon({ type, data });
+  const res = await sendToDaemon({ type, data: target === "all" ? undefined : { target } });
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
@@ -428,9 +406,7 @@ async function cmdStop(args: string[]) {
 async function cmdRestart(args: string[]) {
   const target = args[0] || "all";
   const type = target === "all" ? "restartAll" : "restart";
-  const data = target === "all" ? undefined : { target };
-
-  const res = await sendToDaemon({ type, data });
+  const res = await sendToDaemon({ type, data: target === "all" ? undefined : { target } });
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
@@ -441,9 +417,7 @@ async function cmdRestart(args: string[]) {
 async function cmdReload(args: string[]) {
   const target = args[0] || "all";
   const type = target === "all" ? "reloadAll" : "reload";
-  const data = target === "all" ? undefined : { target };
-
-  const res = await sendToDaemon({ type, data });
+  const res = await sendToDaemon({ type, data: target === "all" ? undefined : { target } });
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
@@ -454,9 +428,7 @@ async function cmdReload(args: string[]) {
 async function cmdDelete(args: string[]) {
   const target = args[0] || "all";
   const type = target === "all" ? "deleteAll" : "delete";
-  const data = target === "all" ? undefined : { target };
-
-  const res = await sendToDaemon({ type, data });
+  const res = await sendToDaemon({ type, data: target === "all" ? undefined : { target } });
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
@@ -480,50 +452,21 @@ 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(`  CWD          : ${p.pm2_env.cwd}`);
-    console.log(`  Args         : ${p.pm2_env.args.join(" ") || "(none)"}`);
-    console.log(`  Interpreter  : ${p.pm2_env.interpreter || "bun"}`);
+    console.log(`  Log (out)    : ${p.pm2_env.pm_out_log_path}`);
+    console.log(`  Log (err)    : ${p.pm2_env.pm_err_log_path}`);
     console.log(`  Restarts     : ${p.pm2_env.restart_time}`);
-    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();
+    console.log(`  CPU          : ${p.monit.cpu.toFixed(1)}%`);
   }
 }
 
@@ -531,26 +474,17 @@ 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(colorize("--- stdout ---", "dim"));
-      console.log(log.out);
-    }
-    if (log.err) {
-      console.log(colorize("--- stderr ---", "red"));
-      console.log(log.err);
-    }
+    if (log.out) console.log(log.out);
+    if (log.err) console.log(colorize(log.err, "red"));
   }
 }
 
@@ -571,7 +505,6 @@ 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"));
@@ -598,31 +531,13 @@ async function cmdResurrect() {
   printProcessTable(res.data);
 }
 
-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 cmdKill() {
+  try {
+    await sendToDaemon({ type: "kill" });
+  } catch { /* ignore */ }
+  await Bun.sleep(500);
+  cleanupStaleFiles();
+  console.log(colorize("✓ Daemon killed", "green"));
 }
 
 async function cmdMonit() {
@@ -631,343 +546,16 @@ 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(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"));
+  console.log(`System: CPU ${snapshot.system.cpuCount} cores | Load ${snapshot.system.loadAvg[0]?.toFixed(2)}`);
   for (const p of snapshot.processes) {
-    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(`${padRight(p.name, 20)} ${colorize(p.status, statusColor(p.status))} CPU: ${p.cpu.toFixed(1)}% Mem: ${formatBytes(p.memory)}`);
   }
-  console.log(res.data);
 }
 
 // ---------------------------------------------------------------------------
-// Help
-// ---------------------------------------------------------------------------
-
-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
+// Main Dispatch
 // ---------------------------------------------------------------------------
 
 const args = process.argv.slice(2);
@@ -975,103 +563,25 @@ 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 "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 "-h":
-  case "--help":
   case undefined:
-    printHelp();
+    console.log(`BM2 v${VERSION} - Usage: bm2 <command> [options]`);
     break;
   default:
     console.error(colorize(`Unknown command: ${command}`, "red"));
-    console.error(`Run ${colorize("bm2 --help", "cyan")} for usage information.`);
     process.exit(1);
 }