bm2 1.0.0

package/src/env-manager.ts

@@ -0,0 +1,77 @@
+/**
+ * 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 { join } from "path";
+import { BM2_HOME } from "./constants";
+
+export class EnvManager {
+  private envFile = join(BM2_HOME, "env-registry.json");
+
+  async getEnvs(): Promise<Record<string, Record<string, string>>> {
+    try {
+      const file = Bun.file(this.envFile);
+      if (await file.exists()) return await file.json();
+    } catch {}
+    return {};
+  }
+
+  async setEnv(name: string, key: string, value: string): Promise<void> {
+    const envs = await this.getEnvs();
+    if (!envs[name]) envs[name] = {};
+    envs[name][key] = value;
+    await Bun.write(this.envFile, JSON.stringify(envs, null, 2));
+  }
+
+  async getEnv(name: string): Promise<Record<string, string>> {
+    const envs = await this.getEnvs();
+    return envs[name] || {};
+  }
+
+  async deleteEnv(name: string, key?: string): Promise<void> {
+    const envs = await this.getEnvs();
+    if (key) {
+      delete envs[name]?.[key];
+    } else {
+      delete envs[name];
+    }
+    await Bun.write(this.envFile, JSON.stringify(envs, null, 2));
+  }
+
+  async loadDotEnv(filePath: string): Promise<Record<string, string>> {
+    const file = Bun.file(filePath);
+    if (!(await file.exists())) return {};
+
+    const content = await file.text();
+    const env: Record<string, string> = {};
+
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx === -1) continue;
+      const key = trimmed.substring(0, eqIdx).trim();
+      let value = trimmed.substring(eqIdx + 1).trim();
+      // Remove quotes
+      if ((value.startsWith('"') && value.endsWith('"')) ||
+          (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+      env[key] = value;
+    }
+
+    return env;
+  }
+}

package/src/graceful-reload.ts

@@ -0,0 +1,71 @@
+/**
+ * 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 { ProcessContainer } from "./process-container";
+ 
+ export class GracefulReload {
+     async reload(
+       containers: ProcessContainer[],
+       options: {
+         delay?: number;
+         listenTimeout?: number;
+       } = {}
+     ): Promise<void> {
+       const delay = options.delay || 1000;
+       const listenTimeout = options.listenTimeout || 3000;
+     
+       for (let i = 0; i < containers.length; i++) {
+         const container = containers[i];
+         if (!container) continue;
+         
+         const oldPid = container.pid;
+     
+         console.log(`[bm2] Graceful reload: reloading ${container.name} (${i + 1}/${containers.length})`);
+     
+         const startPromise = container.start();
+     
+         if (container.config.waitReady) {
+           await Promise.race([
+             new Promise<void>((resolve) => {
+               const checkReady = setInterval(() => {
+                 if (container.status === "online") {
+                   clearInterval(checkReady);
+                   resolve();
+                 }
+               }, 100);
+             }),
+             new Promise<void>((resolve) =>
+               setTimeout(resolve, listenTimeout)
+             ),
+           ]);
+         } else {
+           await startPromise;
+           await new Promise((resolve) => setTimeout(resolve, delay));
+         }
+     
+         if (oldPid) {
+           try {
+             process.kill(oldPid, "SIGTERM");
+           } catch {}
+         }
+     
+         if (i < containers.length - 1) {
+           await new Promise((resolve) => setTimeout(resolve, delay));
+         }
+       }
+     
+       console.log(`[bm2] Graceful reload complete`);
+     }
+ }

package/src/health-checker.ts

@@ -0,0 +1,112 @@
+/**
+ * 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 { HealthCheckConfig } from "./types";
+
+export class HealthChecker {
+  private checks: Map<number, {
+    config: HealthCheckConfig;
+    timer: ReturnType<typeof setInterval>;
+    consecutiveFails: number;
+    lastStatus: "healthy" | "unhealthy" | "unknown";
+    lastCheck: number;
+    lastResponseTime: number;
+  }> = new Map();
+
+  startCheck(
+    processId: number,
+    config: HealthCheckConfig,
+    onUnhealthy: (processId: number, reason: string) => void
+  ) {
+    this.stopCheck(processId);
+
+    const state: {
+      config: HealthCheckConfig;
+      timer: ReturnType<typeof setInterval>;
+      consecutiveFails: number;
+      lastStatus: "healthy" | "unhealthy" | "unknown";
+      lastCheck: number;
+      lastResponseTime: number;
+    } = {
+      config,
+      consecutiveFails: 0,
+      lastStatus: "unknown",
+      lastCheck: 0,
+      lastResponseTime: 0,
+      timer: setInterval(async () => {
+        const start = Date.now();
+        try {
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), config.timeout);
+
+          const response = await fetch(config.url, {
+            signal: controller.signal,
+            method: "GET",
+          });
+
+          clearTimeout(timeout);
+          state.lastResponseTime = Date.now() - start;
+          state.lastCheck = Date.now();
+
+          if (response.ok) {
+            state.consecutiveFails = 0;
+            state.lastStatus = "healthy";
+          } else {
+            state.consecutiveFails++;
+            state.lastStatus = "unhealthy";
+          }
+        } catch {
+          state.consecutiveFails++;
+          state.lastStatus = "unhealthy";
+          state.lastResponseTime = Date.now() - start;
+          state.lastCheck = Date.now();
+        }
+
+        if (state.consecutiveFails >= config.maxFails) {
+          onUnhealthy(processId, `Health check failed ${state.consecutiveFails} times consecutively`);
+          state.consecutiveFails = 0;
+        }
+      }, config.interval),
+    };
+
+    this.checks.set(processId, state);
+  }
+
+  stopCheck(processId: number) {
+    const check = this.checks.get(processId);
+    if (check) {
+      clearInterval(check.timer);
+      this.checks.delete(processId);
+    }
+  }
+
+  getStatus(processId: number) {
+    const check = this.checks.get(processId);
+    if (!check) return null;
+    return {
+      status: check.lastStatus,
+      lastCheck: check.lastCheck,
+      lastResponseTime: check.lastResponseTime,
+      consecutiveFails: check.consecutiveFails,
+    };
+  }
+
+  stopAll() {
+    for (const [id] of this.checks) {
+      this.stopCheck(id);
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+/**
+ * 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>
+ */

package/src/log-manager.ts

@@ -0,0 +1,201 @@
+/**
+ * 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 { join, dirname } from "path";
+import { existsSync, readdirSync, unlinkSync, renameSync, statSync } from "fs";
+import { LOG_DIR, DEFAULT_LOG_MAX_SIZE, DEFAULT_LOG_RETAIN } from "./constants";
+import type { LogRotateOptions } from "./types";
+
+export class LogManager {
+  private writeBuffers: Map<string, string[]> = new Map();
+  private flushTimers: Map<string, ReturnType<typeof setTimeout>> = new Map();
+
+  getLogPaths(name: string, id: number, customOut?: string, customErr?: string) {
+    return {
+      outFile: customOut || join(LOG_DIR, `${name}-${id}-out.log`),
+      errFile: customErr || join(LOG_DIR, `${name}-${id}-error.log`),
+    };
+  }
+
+  async appendLog(filePath: string, data: string | Uint8Array) {
+    const text = typeof data === "string" ? data : new TextDecoder().decode(data);
+
+    // Buffer writes for performance
+    if (!this.writeBuffers.has(filePath)) {
+      this.writeBuffers.set(filePath, []);
+    }
+    this.writeBuffers.get(filePath)!.push(text);
+
+    // Debounced flush
+    if (!this.flushTimers.has(filePath)) {
+      this.flushTimers.set(filePath, setTimeout(() => {
+        this.flushBuffer(filePath);
+      }, 100));
+    }
+  }
+
+  private async flushBuffer(filePath: string) {
+    const buffer = this.writeBuffers.get(filePath);
+    if (!buffer || buffer.length === 0) return;
+
+    const content = buffer.join("");
+    this.writeBuffers.set(filePath, []);
+    this.flushTimers.delete(filePath);
+
+    try {
+      const file = Bun.file(filePath);
+      const existing = (await file.exists()) ? await file.text() : "";
+      await Bun.write(filePath, existing + content);
+    } catch (err) {
+      // If file too large, log the error
+      console.error(`[bm2] Failed to write log: ${filePath}`, err);
+    }
+  }
+
+  async forceFlush() {
+    for (const [filePath] of this.writeBuffers) {
+      await this.flushBuffer(filePath);
+    }
+  }
+
+  async readLogs(
+    name: string,
+    id: number,
+    lines: number = 20,
+    customOut?: string,
+    customErr?: string
+  ): Promise<{ out: string; err: string }> {
+    const paths = this.getLogPaths(name, id, customOut, customErr);
+    let out = "";
+    let err = "";
+
+    try {
+      const outFile = Bun.file(paths.outFile);
+      if (await outFile.exists()) {
+        const text = await outFile.text();
+        out = text.split("\n").slice(-lines).join("\n");
+      }
+    } catch {}
+
+    try {
+      const errFile = Bun.file(paths.errFile);
+      if (await errFile.exists()) {
+        const text = await errFile.text();
+        err = text.split("\n").slice(-lines).join("\n");
+      }
+    } catch {}
+
+    return { out, err };
+  }
+
+  async tailLog(
+    filePath: string,
+    callback: (line: string) => void,
+    signal?: AbortSignal
+  ): Promise<void> {
+    let lastSize = 0;
+    const file = Bun.file(filePath);
+    if (await file.exists()) {
+      lastSize = file.size;
+    }
+
+    const interval = setInterval(async () => {
+      if (signal?.aborted) {
+        clearInterval(interval);
+        return;
+      }
+      try {
+        const f = Bun.file(filePath);
+        if (!(await f.exists())) return;
+        const currentSize = f.size;
+        if (currentSize > lastSize) {
+          const text = await f.text();
+          const newContent = text.substring(lastSize);
+          lastSize = currentSize;
+          for (const line of newContent.split("\n").filter(Boolean)) {
+            callback(line);
+          }
+        }
+      } catch {}
+    }, 500);
+  }
+
+  async rotate(filePath: string, options: LogRotateOptions): Promise<void> {
+    try {
+      const file = Bun.file(filePath);
+      if (!(await file.exists())) return;
+
+      const stat = statSync(filePath);
+      if (stat.size < options.maxSize) return;
+
+      // Rotate files
+      for (let i = options.retain - 1; i >= 1; i--) {
+        const src = i === 1 ? filePath : `${filePath}.${i - 1}`;
+        const dst = `${filePath}.${i}`;
+        if (existsSync(src)) {
+          renameSync(src, dst);
+
+          if (options.compress && i > 0) {
+            // Compress rotated file using Bun's gzip
+            try {
+              const content = await Bun.file(dst).arrayBuffer();
+              const compressed = Bun.gzipSync(new Uint8Array(content));
+              await Bun.write(`${dst}.gz`, compressed);
+              unlinkSync(dst);
+            } catch {}
+          }
+        }
+      }
+
+      // Clean excess rotated files
+      const dir = dirname(filePath);
+      const baseName = filePath.split("/").pop()!;
+      try {
+        const files = readdirSync(dir);
+        const rotated = files
+          .filter((f) => f.startsWith(baseName + "."))
+          .sort()
+          .reverse();
+        for (let i = options.retain; i < rotated.length; i++) {
+          unlinkSync(join(dir, rotated[i]!));
+        }
+      } catch {}
+
+      // Truncate original
+      await Bun.write(filePath, "");
+    } catch (err) {
+      console.error(`[bm2] Log rotation failed for ${filePath}:`, err);
+    }
+  }
+
+  async flush(name: string, id: number, customOut?: string, customErr?: string) {
+    const paths = this.getLogPaths(name, id, customOut, customErr);
+    try { await Bun.write(paths.outFile, ""); } catch {}
+    try { await Bun.write(paths.errFile, ""); } catch {}
+  }
+
+  async checkRotation(
+    name: string,
+    id: number,
+    options: LogRotateOptions,
+    customOut?: string,
+    customErr?: string
+  ) {
+    const paths = this.getLogPaths(name, id, customOut, customErr);
+    await this.rotate(paths.outFile, options);
+    await this.rotate(paths.errFile, options);
+  }
+}

package/src/module-manager.ts

@@ -0,0 +1,119 @@
+/**
+ * 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 { join } from "path";
+ import { MODULE_DIR } from "./constants";
+ import { existsSync, readdirSync } from "fs";
+ import type { ProcessManager } from "./process-manager";
+ 
+ export interface BM2Module {
+   name: string;
+   version: string;
+   init(pm: ProcessManager): void | Promise<void>;
+   destroy?(): void | Promise<void>;
+ }
+ 
+ export class ModuleManager {
+   private modules: Map<string, BM2Module> = new Map();
+   private pm: ProcessManager;
+ 
+   constructor(pm: ProcessManager) {
+     this.pm = pm;
+   }
+ 
+   async install(moduleNameOrPath: string): Promise<string> {
+     const targetDir = join(MODULE_DIR, moduleNameOrPath.replace(/[^a-zA-Z0-9_-]/g, "_"));
+ 
+     if (moduleNameOrPath.startsWith("http") || moduleNameOrPath.startsWith("git")) {
+       // Clone from git
+       const proc = Bun.spawn(["git", "clone", moduleNameOrPath, targetDir], {
+         stdout: "pipe", stderr: "pipe",
+       });
+       await proc.exited;
+     } else if (moduleNameOrPath.startsWith("/") || moduleNameOrPath.startsWith(".")) {
+       // Local path - symlink
+       const { symlinkSync } = require("fs");
+       symlinkSync(moduleNameOrPath, targetDir);
+     } else {
+       // npm package
+       const proc = Bun.spawn(["bun", "add", moduleNameOrPath], {
+         cwd: MODULE_DIR,
+         stdout: "pipe", stderr: "pipe",
+       });
+       await proc.exited;
+     }
+ 
+     // Install deps
+     if (existsSync(join(targetDir, "package.json"))) {
+       const proc = Bun.spawn(["bun", "install"], {
+         cwd: targetDir,
+         stdout: "pipe", stderr: "pipe",
+       });
+       await proc.exited;
+     }
+ 
+     // Load
+     await this.load(targetDir);
+     return targetDir;
+   }
+ 
+   async load(modulePath: string): Promise<void> {
+     try {
+       const pkg = await Bun.file(join(modulePath, "package.json")).json();
+       const main = pkg.main || pkg.module || "index.ts";
+       const mod: BM2Module = (await import(join(modulePath, main))).default;
+ 
+       if (!mod.name) mod.name = pkg.name;
+       if (!mod.version) mod.version = pkg.version;
+ 
+       await mod.init(this.pm);
+       this.modules.set(mod.name, mod);
+       console.log(`[bm2] Module loaded: ${mod.name}@${mod.version}`);
+     } catch (err: any) {
+       console.error(`[bm2] Failed to load module ${modulePath}:`, err.message);
+     }
+   }
+ 
+   async uninstall(name: string): Promise<void> {
+     const mod = this.modules.get(name);
+     if (mod?.destroy) await mod.destroy();
+     this.modules.delete(name);
+ 
+     const modPath = join(MODULE_DIR, name);
+     if (existsSync(modPath)) {
+       const { rmSync } = require("fs");
+       rmSync(modPath, { recursive: true, force: true });
+     }
+   }
+ 
+   async loadAll(): Promise<void> {
+     if (!existsSync(MODULE_DIR)) return;
+     const entries = readdirSync(MODULE_DIR);
+     for (const entry of entries) {
+       const modPath = join(MODULE_DIR, entry);
+       if (existsSync(join(modPath, "package.json"))) {
+         await this.load(modPath);
+       }
+     }
+   }
+ 
+   list(): Array<{ name: string; version: string }> {
+     return Array.from(this.modules.values()).map((m) => ({
+       name: m.name,
+       version: m.version,
+     }));
+   }
+ }