bm2 1.0.0

package/src/monitor.ts

@@ -0,0 +1,185 @@
+/**
+ * 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 { MetricSnapshot, ProcessState } from "./types";
+import { getSystemInfo } from "./utils";
+import { METRICS_DIR } from "./constants";
+import { join } from "path";
+
+export class Monitor {
+  private history: MetricSnapshot[] = [];
+  private maxHistory = 3600; // 1 hour at 1s intervals
+
+  async collectProcessMetrics(
+    pid: number
+  ): Promise<{ memory: number; cpu: number; handles?: number }> {
+    try {
+      if (process.platform === "linux") {
+        const statusFile = Bun.file(`/proc/${pid}/status`);
+        const statFile = Bun.file(`/proc/${pid}/stat`);
+
+        let memory = 0;
+        let cpu = 0;
+        let handles: number | undefined;
+
+        if (await statusFile.exists()) {
+          const content = await statusFile.text();
+          const vmRss = content.match(/VmRSS:\s+(\d+)\s+kB/);
+          
+          if (vmRss) memory = parseInt(vmRss[1]!) * 1024;
+         
+          // Count file descriptors
+          try {
+            const { readdirSync } = require("fs");
+            const fds = readdirSync(`/proc/${pid}/fd`);
+            handles = fds.length;
+          } catch {}
+        }
+
+        if (await statFile.exists()) {
+          const stat = await statFile.text();
+          const parts = stat.split(" ");
+          
+          const utime = parseInt(parts[13]!) || 0;
+          const stime = parseInt(parts[14]!) || 0;
+          
+          // Simplified CPU calculation
+          cpu = (utime + stime) / 100;
+        }
+
+        return { memory, cpu, handles };
+      } else {
+        // macOS / fallback
+        const ps = Bun.spawn(
+          ["ps", "-o", "rss=,pcpu=", "-p", String(pid)],
+          { stdout: "pipe", stderr: "pipe" }
+        );
+        const output = await new Response(ps.stdout).text();
+        const parts = output.trim().split(/\s+/);
+        
+        if (parts.length >= 2) {
+          return {
+            memory: parseInt(parts[0]!) * 1024,
+            cpu: parseFloat(parts[1]!),
+          };
+        }
+      }
+    } catch {}
+
+    return { memory: 0, cpu: 0 };
+  }
+
+  async takeSnapshot(processes: ProcessState[]): Promise<MetricSnapshot> {
+    const system = getSystemInfo();
+    const snapshot: MetricSnapshot = {
+      timestamp: Date.now(),
+      processes: processes.map((p) => ({
+        id: p.id,
+        name: p.name,
+        pid: p.pid,
+        cpu: p.monit.cpu,
+        memory: p.monit.memory,
+        eventLoopLatency: p.monit.eventLoopLatency,
+        handles: p.monit.handles,
+        status: p.status,
+        restarts: p.pm2_env.restart_time,
+        uptime: p.pm2_env.status === "online" ? Date.now() - p.pm2_env.pm_uptime : 0,
+      })),
+      system: {
+        totalMemory: system.totalMemory,
+        freeMemory: system.freeMemory,
+        cpuCount: system.cpuCount,
+        loadAvg: system.loadAvg,
+        platform: system.platform,
+      },
+    };
+
+    this.history.push(snapshot);
+    if (this.history.length > this.maxHistory) {
+      this.history = this.history.slice(-this.maxHistory);
+    }
+
+    return snapshot;
+  }
+
+  getHistory(seconds: number = 300): MetricSnapshot[] {
+    const cutoff = Date.now() - seconds * 1000;
+    return this.history.filter((s) => s.timestamp >= cutoff);
+  }
+
+  getLatest(): MetricSnapshot | null {
+    return this.history.length > 0 ? this.history[this.history.length - 1]! : null;
+  }
+
+  async saveMetrics(): Promise<void> {
+    const filePath = join(METRICS_DIR, `metrics-${Date.now()}.json`);
+    await Bun.write(filePath, JSON.stringify(this.history.slice(-300)));
+  }
+
+  generatePrometheusMetrics(processes: ProcessState[]): string {
+    const lines: string[] = [];
+
+    lines.push("# HELP bm2_process_cpu CPU usage percentage");
+    lines.push("# TYPE bm2_process_cpu gauge");
+    for (const p of processes) {
+      lines.push(`bm2_process_cpu{name="${p.name}",id="${p.pm_id}"} ${p.monit.cpu}`);
+    }
+
+    lines.push("# HELP bm2_process_memory_bytes Memory usage in bytes");
+    lines.push("# TYPE bm2_process_memory_bytes gauge");
+    for (const p of processes) {
+      lines.push(`bm2_process_memory_bytes{name="${p.name}",id="${p.pm_id}"} ${p.monit.memory}`);
+    }
+
+    lines.push("# HELP bm2_process_restarts_total Total restart count");
+    lines.push("# TYPE bm2_process_restarts_total counter");
+    for (const p of processes) {
+      lines.push(`bm2_process_restarts_total{name="${p.name}",id="${p.pm_id}"} ${p.pm2_env.restart_time}`);
+    }
+
+    lines.push("# HELP bm2_process_uptime_seconds Process uptime in seconds");
+    lines.push("# TYPE bm2_process_uptime_seconds gauge");
+    for (const p of processes) {
+      const uptime = p.pm2_env.status === "online"
+        ? (Date.now() - p.pm2_env.pm_uptime) / 1000
+        : 0;
+      lines.push(`bm2_process_uptime_seconds{name="${p.name}",id="${p.pm_id}"} ${uptime.toFixed(0)}`);
+    }
+
+    lines.push("# HELP bm2_process_status Process status (1=online)");
+    lines.push("# TYPE bm2_process_status gauge");
+    for (const p of processes) {
+      lines.push(`bm2_process_status{name="${p.name}",id="${p.pm_id}",status="${p.status}"} ${p.status === "online" ? 1 : 0}`);
+    }
+
+    const sys = getSystemInfo();
+    lines.push("# HELP bm2_system_memory_total_bytes Total system memory");
+    lines.push("# TYPE bm2_system_memory_total_bytes gauge");
+    lines.push(`bm2_system_memory_total_bytes ${sys.totalMemory}`);
+
+    lines.push("# HELP bm2_system_memory_free_bytes Free system memory");
+    lines.push("# TYPE bm2_system_memory_free_bytes gauge");
+    lines.push(`bm2_system_memory_free_bytes ${sys.freeMemory}`);
+
+    lines.push("# HELP bm2_system_load_average System load average");
+    lines.push("# TYPE bm2_system_load_average gauge");
+    lines.push(`bm2_system_load_average{period="1m"} ${sys.loadAvg[0]}`);
+    lines.push(`bm2_system_load_average{period="5m"} ${sys.loadAvg[1]}`);
+    lines.push(`bm2_system_load_average{period="15m"} ${sys.loadAvg[2]}`);
+
+    return lines.join("\n") + "\n";
+  }
+}

package/src/process-container.ts

@@ -0,0 +1,508 @@
+/**
+ * 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,
+  ProcessState,
+  ProcessStatus,
+  LogRotateOptions,
+} from "./types";
+import { LogManager } from "./log-manager";
+import { ClusterManager } from "./cluster-manager";
+import { HealthChecker } from "./health-checker";
+import { CronManager } from "./cron-manager";
+import { treeKill } from "./utils";
+import { join } from "path";
+import {
+  PID_DIR,
+  MONITOR_INTERVAL,
+  DEFAULT_LOG_MAX_SIZE,
+  DEFAULT_LOG_RETAIN,
+} from "./constants";
+
+export class ProcessContainer {
+  public id: number;
+  public name: string;
+  public config: ProcessDescription;
+  public status: ProcessStatus = "stopped";
+  public process: Subprocess | null = null;
+  public pid: number | undefined;
+  public restartCount: number = 0;
+  public unstableRestarts: number = 0;
+  public createdAt: number;
+  public startedAt: number = 0;
+  public memory: number = 0;
+  public cpu: number = 0;
+  public handles: number = 0;
+  public eventLoopLatency: number = 0;
+  public axmMonitor: Record<string, any> = {};
+
+  private logManager: LogManager;
+  private clusterManager: ClusterManager;
+  private healthChecker: HealthChecker;
+  private cronManager: CronManager;
+  private restartTimer: ReturnType<typeof setTimeout> | null = null;
+  private watcher: ReturnType<typeof import("fs").watch> | null = null;
+  private monitorInterval: ReturnType<typeof setInterval> | null = null;
+  private logRotateInterval: ReturnType<typeof setInterval> | null = null;
+  private isRestarting: boolean = false;
+
+  constructor(
+    id: number,
+    config: ProcessDescription,
+    logManager: LogManager,
+    clusterManager: ClusterManager,
+    healthChecker: HealthChecker,
+    cronManager: CronManager
+  ) {
+    this.id = id;
+    this.name = config.name;
+    this.config = config;
+    this.logManager = logManager;
+    this.clusterManager = clusterManager;
+    this.healthChecker = healthChecker;
+    this.cronManager = cronManager;
+    this.createdAt = Date.now();
+  }
+
+  async start(): Promise<void> {
+    if (this.status === "online") return;
+
+    this.status = "launching";
+    const logPaths = this.logManager.getLogPaths(
+      this.name,
+      this.id,
+      this.config.outFile,
+      this.config.errorFile
+    );
+
+    try {
+      // Ensure log files exist
+      for (const f of [logPaths.outFile, logPaths.errFile]) {
+        const file = Bun.file(f);
+        if (!(await file.exists())) await Bun.write(f, "");
+      }
+
+      if (this.config.execMode === "cluster" && this.config.instances > 1) {
+        await this.startCluster(logPaths);
+      } else {
+        await this.startFork(logPaths);
+      }
+
+      this.startedAt = Date.now();
+      this.status = "online";
+
+      // Write PID file
+      if (this.pid) {
+        await Bun.write(
+          join(PID_DIR, `${this.name}-${this.id}.pid`),
+          String(this.pid)
+        );
+      }
+
+      // Start monitoring
+      this.startMonitoring();
+
+      // Start log rotation
+      this.startLogRotation(logPaths);
+
+      // Setup watch mode
+      if (this.config.watch) {
+        this.setupWatch();
+      }
+
+      // Setup health checks
+      if (this.config.healthCheckUrl) {
+        this.healthChecker.startCheck(
+          this.id,
+          {
+            url: this.config.healthCheckUrl,
+            interval: this.config.healthCheckInterval || 30000,
+            timeout: this.config.healthCheckTimeout || 5000,
+            maxFails: this.config.healthCheckMaxFails || 3,
+          },
+          (_id, reason) => {
+            console.log(`[bm2] Health check failed for ${this.name}: ${reason}`);
+            this.restart();
+          }
+        );
+      }
+
+      // Setup cron restart
+      if (this.config.cronRestart) {
+        this.cronManager.schedule(this.id, this.config.cronRestart, () => {
+          console.log(`[bm2] Cron restart triggered for ${this.name}`);
+          this.restart();
+        });
+      }
+    } catch (err: any) {
+      this.status = "errored";
+      const timestamp = new Date().toISOString();
+      await this.logManager.appendLog(
+        logPaths.errFile,
+        `[${timestamp}] [bm2] Failed to start: ${err.message}\n`
+      );
+      throw err;
+    }
+  }
+
+  private async startFork(logPaths: { outFile: string; errFile: string }) {
+    const cmd = this.clusterManager.buildWorkerCommand(this.config);
+    const env: Record<string, string> = {
+      ...(process.env as Record<string, string>),
+      ...this.config.env,
+      BM2_ID: String(this.id),
+      BM2_NAME: this.name,
+      BM2_EXEC_MODE: "fork",
+    };
+
+    this.process = Bun.spawn(cmd, {
+      cwd: this.config.cwd || process.cwd(),
+      env,
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore",
+    });
+
+    this.pid = this.process.pid;
+    this.pipeOutput(logPaths);
+
+    this.process.exited.then((code) => {
+      if (!this.isRestarting) {
+        this.handleExit(code);
+      }
+    });
+  }
+
+  private async startCluster(logPaths: { outFile: string; errFile: string }) {
+    const proc = this.clusterManager.spawnWorker(
+      this.config,
+      0,
+      this.config.instances,
+      { stdout: "pipe", stderr: "pipe" }
+    );
+
+    this.process = proc;
+    this.pid = proc.pid;
+
+    if (proc.stdout && typeof proc.stdout !== "number") {
+      this.pipeStream(proc.stdout, logPaths.outFile);
+    }
+    if (proc.stderr && typeof proc.stderr !== "number") {
+      this.pipeStream(proc.stderr, logPaths.errFile);
+    }
+
+    proc.exited.then((code) => {
+      if (!this.isRestarting) {
+        this.handleExit(code);
+      }
+    });
+  }
+
+  private pipeOutput(logPaths: { outFile: string; errFile: string }) {
+    if (!this.process) return;
+    if (this.process.stdout && typeof this.process.stdout !== "number") {
+      this.pipeStream(this.process.stdout, logPaths.outFile);
+    }
+    if (this.process.stderr && typeof this.process.stderr !== "number") {
+      this.pipeStream(this.process.stderr, logPaths.errFile);
+    }
+  }
+
+  private async pipeStream(stream: ReadableStream<Uint8Array>, filePath: string) {
+    const reader = stream.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const text = new TextDecoder().decode(value);
+        const timestamp = new Date().toISOString();
+        const lines = text.split("\n").filter(Boolean);
+        for (const line of lines) {
+          await this.logManager.appendLog(filePath, `[${timestamp}] ${line}\n`);
+        }
+      }
+    } catch {}
+  }
+
+  private startMonitoring() {
+    this.monitorInterval = setInterval(async () => {
+      if (!this.pid || this.status !== "online") return;
+
+      try {
+        if (process.platform === "linux") {
+          const statusFile = Bun.file(`/proc/${this.pid}/status`);
+          if (await statusFile.exists()) {
+            const content = await statusFile.text();
+            const vmRss = content.match(/VmRSS:\s+(\d+)\s+kB/);
+            if (vmRss) this.memory = parseInt(vmRss[1]!) * 1024;
+          }
+
+          try {
+            const { readdirSync } = require("fs");
+            this.handles = readdirSync(`/proc/${this.pid}/fd`).length;
+          } catch {}
+        } else {
+          const ps = Bun.spawn(["ps", "-o", "rss=,pcpu=", "-p", String(this.pid)], {
+            stdout: "pipe", stderr: "pipe",
+          });
+          const output = await new Response(ps.stdout).text();
+          const parts = output.trim().split(/\s+/);
+          if (parts.length >= 2) {
+            this.memory = parseInt(parts[0]!) * 1024;
+            this.cpu = parseFloat(parts[1]!);
+          }
+        }
+
+        // Max memory restart
+        if (this.config.maxMemoryRestart && this.memory > this.config.maxMemoryRestart) {
+          console.log(`[bm2] ${this.name} exceeded memory limit (${this.memory} > ${this.config.maxMemoryRestart}), restarting...`);
+          await this.restart();
+        }
+      } catch {}
+    }, MONITOR_INTERVAL);
+  }
+
+  private startLogRotation(logPaths: { outFile: string; errFile: string }) {
+    const rotateOpts: LogRotateOptions = {
+      maxSize: this.config.logMaxSize || DEFAULT_LOG_MAX_SIZE,
+      retain: this.config.logRetain || DEFAULT_LOG_RETAIN,
+      compress: this.config.logCompress || false,
+    };
+
+    this.logRotateInterval = setInterval(() => {
+      this.logManager.checkRotation(
+        this.name,
+        this.id,
+        rotateOpts,
+        this.config.outFile,
+        this.config.errorFile
+      );
+    }, 60000);
+  }
+
+  private setupWatch() {
+    const { watch } = require("fs");
+    const paths = this.config.watchPaths || [this.config.cwd || process.cwd()];
+    const ignorePatterns = this.config.ignoreWatch || ["node_modules", ".git", ".bm2"];
+
+    let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+
+    for (const watchPath of paths) {
+      try {
+        this.watcher = watch(
+          watchPath,
+          { recursive: true },
+          (_event: string, filename: string | null) => {
+            if (!filename) return;
+            if (ignorePatterns.some((p) => filename.includes(p))) return;
+
+            if (debounceTimer) clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(() => {
+              console.log(`[bm2] ${filename} changed, restarting ${this.name}...`);
+              this.restart();
+            }, 1000);
+          }
+        );
+      } catch {}
+    }
+  }
+
+  private handleExit(code: number | null) {
+    const wasOnline = this.status === "online";
+    this.status = code === 0 ? "stopped" : "errored";
+    this.pid = undefined;
+    this.process = null;
+
+    this.cleanupTimers();
+
+    const uptime = Date.now() - this.startedAt;
+
+    if (wasOnline && this.config.autorestart && this.restartCount < this.config.maxRestarts) {
+      if (uptime < this.config.minUptime) {
+        this.unstableRestarts++;
+      }
+
+      this.status = "waiting-restart";
+      const delay = this.config.restartDelay || 0;
+
+      this.restartTimer = setTimeout(() => {
+        this.restartCount++;
+        console.log(`[bm2] Restarting ${this.name} (attempt ${this.restartCount}/${this.config.maxRestarts})`);
+        this.start().catch((err) => {
+          console.error(`[bm2] Failed to restart ${this.name}:`, err);
+        });
+      }, delay);
+    } else if (this.restartCount >= this.config.maxRestarts) {
+      console.log(`[bm2] ${this.name} reached max restarts (${this.config.maxRestarts}), not restarting`);
+      this.status = "errored";
+    }
+  }
+
+  private cleanupTimers() {
+    if (this.monitorInterval) {
+      clearInterval(this.monitorInterval);
+      this.monitorInterval = null;
+    }
+    if (this.logRotateInterval) {
+      clearInterval(this.logRotateInterval);
+      this.logRotateInterval = null;
+    }
+    this.healthChecker.stopCheck(this.id);
+    this.cronManager.cancel(this.id);
+  }
+
+  async stop(force: boolean = false): Promise<void> {
+    if (this.status !== "online" && this.status !== "launching" && this.status !== "waiting-restart") {
+      return;
+    }
+
+    this.isRestarting = false;
+    this.status = "stopping";
+    this.config.autorestart = false;
+
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = null;
+    }
+
+    this.cleanupTimers();
+
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+
+    if (this.process && this.pid) {
+      if (this.config.treekill !== false) {
+        await treeKill(this.pid, "SIGTERM");
+      } else {
+        this.process.kill("SIGTERM" as any);
+      }
+
+      if (!force) {
+        const timeout = this.config.killTimeout || 5000;
+        const exited = await Promise.race([
+          this.process.exited.then(() => true),
+          new Promise<boolean>((r) => setTimeout(() => r(false), timeout)),
+        ]);
+
+        if (!exited && this.process) {
+          if (this.config.treekill !== false && this.pid) {
+            await treeKill(this.pid, "SIGKILL");
+          } else {
+            this.process.kill("SIGKILL" as any);
+          }
+          await this.process.exited;
+        }
+      } else {
+        if (this.config.treekill !== false && this.pid) {
+          await treeKill(this.pid, "SIGKILL");
+        } else {
+          this.process.kill("SIGKILL" as any);
+        }
+        await this.process.exited;
+      }
+    }
+
+    // Clean up cluster workers
+    this.clusterManager.removeAllWorkers(this.id);
+
+    this.status = "stopped";
+    this.pid = undefined;
+    this.process = null;
+    this.memory = 0;
+    this.cpu = 0;
+  }
+
+  async restart(): Promise<void> {
+    this.isRestarting = true;
+    const wasAutoRestart = this.config.autorestart;
+    await this.stop();
+    this.config.autorestart = wasAutoRestart;
+    this.isRestarting = false;
+    await this.start();
+  }
+
+  async reload(): Promise<void> {
+    const oldPid = this.pid;
+    const oldProcess = this.process;
+
+    this.isRestarting = true;
+    this.process = null;
+    this.pid = undefined;
+
+    await this.start();
+
+    // Wait for new process to be stable
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+
+    // Kill old process
+    if (oldProcess && oldPid) {
+      try {
+        if (this.config.treekill !== false) {
+          await treeKill(oldPid, "SIGTERM");
+        } else {
+          oldProcess.kill("SIGTERM" as any);
+        }
+      } catch {}
+    }
+
+    this.isRestarting = false;
+  }
+
+  async sendSignal(signal: string): Promise<void> {
+    if (this.pid) {
+      process.kill(this.pid, signal as any);
+    }
+  }
+
+  getState(): ProcessState {
+    return {
+      id: this.id,
+      name: this.name,
+      namespace: this.config.namespace,
+      status: this.status,
+      pid: this.pid,
+      pm_id: this.id,
+      monit: {
+        memory: this.memory,
+        cpu: this.cpu,
+        handles: this.handles,
+        eventLoopLatency: this.eventLoopLatency,
+      },
+      pm2_env: {
+        ...this.config,
+        status: this.status,
+        pm_uptime: this.startedAt,
+        restart_time: this.restartCount,
+        unstable_restarts: this.unstableRestarts,
+        created_at: this.createdAt,
+        pm_id: this.id,
+        axm_monitor: this.axmMonitor,
+      },
+    };
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      config: this.config,
+      restartCount: this.restartCount,
+    };
+  }
+}