bm2 1.0.0

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "bm2",
+  "version": "1.0.0",
+  "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",
+  "types": "src/index.ts",
+  "bin": {
+    "bm2": "./src/index.ts"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "dev": "bun run --watch src/index.ts",
+    "test": "bun test",
+    "lint": "bun x tsc --noEmit",
+    "prepublishOnly": "bun test"
+  },
+  "keywords": [
+    "bun",
+    "process-manager",
+    "pm2",
+    "pm2-alternative",
+    "cluster",
+    "daemon",
+    "production",
+    "deployment",
+    "monitoring",
+    "prometheus",
+    "zero-downtime",
+    "reload",
+    "log-management",
+    "health-check",
+    "bm2"
+  ],
+  "author": {
+    "name": "MaxxPainn",
+    "email": "hello@maxxpainn.com",
+    "url": "https://maxxpainn.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bun-bm2/bm2.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bun-bm2/bm2/issues",
+    "email": "hello@maxxpainn.com"
+  },
+  "homepage": "https://github.com/bun-bm2/bm2#readme",
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "os": [
+    "linux",
+    "darwin"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "@types/bun": "^1.3.9",
+    "bun-types": "latest",
+    "typescript": "^5.9.3"
+  }
+}

package/src/cluster-manager.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 type { Subprocess } from "bun";
+ import type { ProcessDescription } from "./types";
+ import { getCpuCount } from "./utils";
+ 
+ export class ClusterManager {
+   private workers: Map<number, Map<number, Subprocess>> = new Map();
+ 
+   resolveInstances(instances: number | string | undefined): number {
+     if (instances === undefined || instances === 0) return 1;
+     if (typeof instances === "string") {
+       if (instances === "max" || instances === "-1") return getCpuCount();
+       return parseInt(instances) || 1;
+     }
+     if (instances === -1) return getCpuCount();
+     return instances;
+   }
+ 
+   createWorkerEnv(
+     baseEnv: Record<string, string>,
+     workerId: number,
+     totalWorkers: number,
+     basePort?: number
+   ): Record<string, string> {
+     return {
+       ...baseEnv,
+       BM2_CLUSTER: "true",
+       BM2_WORKER_ID: String(workerId),
+       BM2_INSTANCES: String(totalWorkers),
+       NODE_APP_INSTANCE: String(workerId),
+       ...(basePort ? { PORT: String(basePort + workerId) } : {}),
+     };
+   }
+ 
+   buildWorkerCommand(config: ProcessDescription): string[] {
+     const cmd: string[] = [];
+ 
+     if (config.interpreter) {
+       cmd.push(config.interpreter);
+       if (config.interpreterArgs) cmd.push(...config.interpreterArgs);
+     } else {
+       const ext = config.script.split(".").pop()?.toLowerCase();
+       if (ext === "ts" || ext === "tsx" || ext === "js" || ext === "jsx" || ext === "mjs") {
+         cmd.push("bun", "run");
+       } else if (ext === "py") {
+         cmd.push("python3");
+       } else {
+         cmd.push("bun", "run");
+       }
+     }
+ 
+     if (config.nodeArgs?.length) {
+       cmd.push(...config.nodeArgs);
+     }
+ 
+     cmd.push(config.script);
+     if (config.args?.length) cmd.push(...config.args);
+ 
+     return cmd;
+   }
+ 
+   spawnWorker(
+     config: ProcessDescription,
+     workerId: number,
+     totalWorkers: number,
+     logStreams: { stdout: "pipe" | "inherit"; stderr: "pipe" | "inherit" }
+   ): Subprocess {
+     const cmd = this.buildWorkerCommand(config);
+     const env = this.createWorkerEnv(
+       { ...process.env as Record<string, string>, ...config.env },
+       workerId,
+       totalWorkers,
+       config.port
+     );
+ 
+     const proc = Bun.spawn(cmd, {
+       cwd: config.cwd || process.cwd(),
+       env,
+       stdout: logStreams.stdout,
+       stderr: logStreams.stderr,
+       stdin: "ignore",
+     });
+ 
+     if (!this.workers.has(config.id)) {
+       this.workers.set(config.id, new Map());
+     }
+     this.workers.get(config.id)!.set(workerId, proc);
+ 
+     return proc;
+   }
+ 
+   getWorkers(processId: number): Map<number, Subprocess> | undefined {
+     return this.workers.get(processId);
+   }
+ 
+   removeWorker(processId: number, workerId: number) {
+     this.workers.get(processId)?.delete(workerId);
+   }
+ 
+   removeAllWorkers(processId: number) {
+     this.workers.delete(processId);
+   }
+ }

package/src/constants.ts

@@ -0,0 +1,44 @@
+/**
+ * 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 { homedir } from "os";
+import { join } from "path";
+
+export const APP_NAME = "bm2";
+export const VERSION = "1.0.0";
+
+export const BM2_HOME = join(homedir(), ".bm2");
+export const DAEMON_SOCKET = join(BM2_HOME, "daemon.sock");
+export const DAEMON_PID_FILE = join(BM2_HOME, "daemon.pid");
+export const LOG_DIR = join(BM2_HOME, "logs");
+export const PID_DIR = join(BM2_HOME, "pids");
+export const DUMP_FILE = join(BM2_HOME, "dump.json");
+export const METRICS_DIR = join(BM2_HOME, "metrics");
+export const MODULE_DIR = join(BM2_HOME, "modules");
+export const CONFIG_FILE = join(BM2_HOME, "config.json");
+export const DASHBOARD_PORT = 9615;
+export const METRICS_PORT = 9616;
+
+export const ALL_DIRS = [BM2_HOME, LOG_DIR, PID_DIR, METRICS_DIR, MODULE_DIR];
+
+export const DEFAULT_KILL_TIMEOUT = 5000;
+export const DEFAULT_MIN_UPTIME = 1000;
+export const DEFAULT_MAX_RESTARTS = 16;
+export const DEFAULT_RESTART_DELAY = 0;
+export const DEFAULT_LOG_MAX_SIZE = 10 * 1024 * 1024; // 10MB
+export const DEFAULT_LOG_RETAIN = 5;
+export const MONITOR_INTERVAL = 1000;
+export const HEALTH_CHECK_INTERVAL = 30000;

package/src/cron-manager.ts

@@ -0,0 +1,74 @@
+/**
+ * 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 { parseCron } from "./utils";
+
+export class CronManager {
+  private jobs: Map<number, {
+    expression: string;
+    timer: ReturnType<typeof setTimeout>;
+  }> = new Map();
+
+  schedule(processId: number, expression: string, callback: () => void) {
+    this.cancel(processId);
+
+    const scheduleNext = () => {
+      try {
+        const cron = parseCron(expression);
+        const nextDate = cron.next();
+        const delay = nextDate.getTime() - Date.now();
+
+        if (delay < 0) {
+          // Schedule for next minute at least
+          setTimeout(scheduleNext, 60000);
+          return;
+        }
+
+        const timer = setTimeout(() => {
+          callback();
+          scheduleNext(); // Schedule the next occurrence
+        }, delay);
+
+        this.jobs.set(processId, { expression, timer });
+      } catch (err) {
+        console.error(`[bm2] Cron schedule error for process ${processId}:`, err);
+      }
+    };
+
+    scheduleNext();
+  }
+
+  cancel(processId: number) {
+    const job = this.jobs.get(processId);
+    if (job) {
+      clearTimeout(job.timer);
+      this.jobs.delete(processId);
+    }
+  }
+
+  cancelAll() {
+    for (const [id] of this.jobs) {
+      this.cancel(id);
+    }
+  }
+
+  listJobs() {
+    const result: Array<{ processId: number; expression: string }> = [];
+    for (const [id, job] of this.jobs) {
+      result.push({ processId: id, expression: job.expression });
+    }
+    return result;
+  }
+}

package/src/daemon.ts

@@ -0,0 +1,233 @@
+/**
+ * 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 { ProcessManager } from "./process-manager";
+import { Dashboard } from "./dashboard";
+import { ModuleManager } from "./module-manager";
+import {
+  DAEMON_SOCKET,
+  DAEMON_PID_FILE,
+  DASHBOARD_PORT,
+  METRICS_PORT,
+} from "./constants";
+import { ensureDirs } from "./utils";
+import { unlinkSync, existsSync } from "fs";
+import type { DaemonMessage, DaemonResponse } from "./types";
+import type { ServerWebSocket } from "bun";
+
+ensureDirs();
+
+const pm = new ProcessManager();
+const dashboard = new Dashboard(pm);
+const moduleManager = new ModuleManager(pm);
+
+// Clean up existing socket
+if (existsSync(DAEMON_SOCKET)) {
+  try { unlinkSync(DAEMON_SOCKET); } catch {}
+}
+
+// Write PID file
+await Bun.write(DAEMON_PID_FILE, String(process.pid));
+
+// Load modules
+await moduleManager.loadAll();
+
+// Start metric collection
+const metricsInterval = setInterval(() => {
+  pm.getMetrics();
+}, 2000);
+
+async function handleMessage(msg: DaemonMessage): Promise<DaemonResponse> {
+  try {
+    switch (msg.type) {
+      case "start": {
+        const states = await pm.start(msg.data);
+        return { type: "start", data: states, success: true, id: msg.id };
+      }
+      case "stop": {
+        const states = await pm.stop(msg.data.target);
+        return { type: "stop", data: states, success: true, id: msg.id };
+      }
+      case "restart": {
+        const states = await pm.restart(msg.data.target);
+        return { type: "restart", data: states, success: true, id: msg.id };
+      }
+      case "reload": {
+        const states = await pm.reload(msg.data.target);
+        return { type: "reload", data: states, success: true, id: msg.id };
+      }
+      case "delete": {
+        const states = await pm.del(msg.data.target);
+        return { type: "delete", data: states, success: true, id: msg.id };
+      }
+      case "scale": {
+        const states = await pm.scale(msg.data.target, msg.data.count);
+        return { type: "scale", data: states, success: true, id: msg.id };
+      }
+      case "stopAll": {
+        const states = await pm.stopAll();
+        return { type: "stopAll", data: states, success: true, id: msg.id };
+      }
+      case "restartAll": {
+        const states = await pm.restartAll();
+        return { type: "restartAll", data: states, success: true, id: msg.id };
+      }
+      case "reloadAll": {
+        const states = await pm.reloadAll();
+        return { type: "reloadAll", data: states, success: true, id: msg.id };
+      }
+      case "deleteAll": {
+        const states = await pm.deleteAll();
+        return { type: "deleteAll", data: states, success: true, id: msg.id };
+      }
+      case "list": {
+        return { type: "list", data: pm.list(), success: true, id: msg.id };
+      }
+      case "describe": {
+        return { type: "describe", data: pm.describe(msg.data.target), success: true, id: msg.id };
+      }
+      case "logs": {
+        const logs = await pm.getLogs(msg.data.target, msg.data.lines);
+        return { type: "logs", data: logs, success: true, id: msg.id };
+      }
+      case "flush": {
+        await pm.flushLogs(msg.data?.target);
+        return { type: "flush", success: true, id: msg.id };
+      }
+      case "save": {
+        await pm.save();
+        return { type: "save", success: true, id: msg.id };
+      }
+      case "resurrect": {
+        const states = await pm.resurrect();
+        return { type: "resurrect", data: states, success: true, id: msg.id };
+      }
+      case "ecosystem": {
+        const states = await pm.startEcosystem(msg.data);
+        return { type: "ecosystem", data: states, success: true, id: msg.id };
+      }
+      case "signal": {
+        await pm.sendSignal(msg.data.target, msg.data.signal);
+        return { type: "signal", success: true, id: msg.id };
+      }
+      case "reset": {
+        const states = await pm.reset(msg.data.target);
+        return { type: "reset", data: states, success: true, id: msg.id };
+      }
+      case "metrics": {
+        const metrics = await pm.getMetrics();
+        return { type: "metrics", data: metrics, success: true, id: msg.id };
+      }
+      case "metricsHistory": {
+        const history = pm.getMetricsHistory(msg.data?.seconds || 300);
+        return { type: "metricsHistory", data: history, success: true, id: msg.id };
+      }
+      case "prometheus": {
+        const prom = pm.getPrometheusMetrics();
+        return { type: "prometheus", data: prom, success: true, id: msg.id };
+      }
+      case "dashboard": {
+        const port = msg.data?.port || DASHBOARD_PORT;
+        const metricsPort = msg.data?.metricsPort || METRICS_PORT;
+        dashboard.start(port, metricsPort);
+        return { type: "dashboard", data: { port, metricsPort }, success: true, id: msg.id };
+      }
+      case "dashboardStop": {
+        dashboard.stop();
+        return { type: "dashboardStop", success: true, id: msg.id };
+      }
+      case "moduleInstall": {
+        const path = await moduleManager.install(msg.data.module);
+        return { type: "moduleInstall", data: { path }, success: true, id: msg.id };
+      }
+      case "moduleUninstall": {
+        await moduleManager.uninstall(msg.data.module);
+        return { type: "moduleUninstall", success: true, id: msg.id };
+      }
+      case "moduleList": {
+        return { type: "moduleList", data: moduleManager.list(), success: true, id: msg.id };
+      }
+      case "ping": {
+        return {
+          type: "pong",
+          data: { pid: process.pid, uptime: process.uptime() },
+          success: true,
+          id: msg.id,
+        };
+      }
+      case "kill": {
+        await pm.stopAll();
+        dashboard.stop();
+        clearInterval(metricsInterval);
+        setTimeout(() => process.exit(0), 200);
+        return { type: "kill", success: true, id: msg.id };
+      }
+      default:
+        return { type: "error", error: `Unknown command: ${msg.type}`, success: false, id: msg.id };
+    }
+  } catch (err: any) {
+    return { type: "error", error: err.message, success: false, id: msg.id };
+  }
+}
+
+// Unix socket server
+const server = Bun.serve({
+  unix: DAEMON_SOCKET,
+  fetch(req, server) {
+    if (server.upgrade(req)) return;
+    return new Response("bm2 daemon");
+  },
+  websocket: {
+    async message(ws: ServerWebSocket<unknown>, message) {
+      try {
+        const msg: DaemonMessage = JSON.parse(String(message));
+        const response = await handleMessage(msg);
+        ws.send(JSON.stringify(response));
+      } catch (err: any) {
+        ws.send(JSON.stringify({ type: "error", error: err.message, success: false }));
+      }
+    },
+    open(ws) {},
+    close(ws) {},
+  },
+});
+
+// Signal handlers
+const shutdown = async () => {
+  console.log("\n[bm2] Shutting down daemon...");
+  await pm.stopAll();
+  dashboard.stop();
+  clearInterval(metricsInterval);
+  try { unlinkSync(DAEMON_SOCKET); } catch {}
+  try { unlinkSync(DAEMON_PID_FILE); } catch {}
+  process.exit(0);
+};
+
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+process.on("SIGHUP", shutdown);
+
+// Handle uncaught errors to keep daemon alive
+process.on("uncaughtException", (err) => {
+  console.error("[bm2] Uncaught exception:", err);
+});
+
+process.on("unhandledRejection", (err) => {
+  console.error("[bm2] Unhandled rejection:", err);
+});
+
+console.log(`[bm2] Daemon running (PID: ${process.pid})`);
+console.log(`[bm2] Socket: ${DAEMON_SOCKET}`);