bm2 1.0.23 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bm2",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "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/api.ts",
   "module": "src/api.ts",
@@ -65,10 +65,12 @@
   ],
   "dependencies": {
     "cli-table3": "^0.6.5",
+    "pidusage": "^4.0.1",
     "ws": "^8.19.0"
   },
   "devDependencies": {
     "@types/bun": "^1.3.9",
+    "@types/pidusage": "^2.0.5",
     "@types/ws": "^8.18.1",
     "bun-types": "latest",
     "typescript": "^5.9.3"

package/src/index.ts

@@ -141,7 +141,9 @@ async function sendToDaemon(msg: DaemonMessage): Promise<DaemonResponse> {
 // ---------------------------------------------------------------------------
 
 async function loadEcosystemConfig(filePath: string): Promise<EcosystemConfig> {
+  
   const abs = resolve(filePath);
+  
   if (!existsSync(abs)) {
     throw new Error(`Ecosystem file not found: ${abs}`);
   }

package/src/log-manager.ts

@@ -13,9 +13,10 @@
  * License: GPL-3.0-only
  * Author: Zak <zak@maxxpainn.com>
  */
- 
+
 import { join, dirname } from "path";
-import { existsSync, readdirSync, unlinkSync, renameSync, statSync } from "fs";
+import { openSync, readSync, closeSync } from "fs";
+import { appendFile, stat, rename, unlink, readdir, access } from "fs/promises";
 import { LOG_DIR, DEFAULT_LOG_MAX_SIZE, DEFAULT_LOG_RETAIN } from "./constants";
 import type { LogRotateOptions } from "./types";
 
@@ -56,11 +57,12 @@ export class LogManager {
     this.flushTimers.delete(filePath);
 
     try {
-      const file = Bun.file(filePath);
-      const existing = (await file.exists()) ? await file.text() : "";
-      await Bun.write(filePath, existing + content);
+      // Use appendFile (O_APPEND) instead of read-entire-file-then-rewrite.
+      // The old Bun.write approach pulled the whole log into a JS string on
+      // every flush — O(file size) memory per flush, quadratic overall.
+      // appendFile seeks to EOF at the kernel level and writes only new bytes.
+      await appendFile(filePath, content, { encoding: "utf8" });
     } catch (err) {
-      // If file too large, log the error
       console.error(`[bm2] Failed to write log: ${filePath}`, err);
     }
   }
@@ -120,14 +122,29 @@ export class LogManager {
       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);
-          }
+        if (currentSize <= lastSize) return;
+
+        const byteLength = currentSize - lastSize;
+
+        // Read only the new bytes via fs.readSync to avoid:
+        //   1. Loading the entire file into memory on every poll.
+        //   2. Slicing by character offset (lastSize) on a UTF-8 string,
+        //      which silently corrupts multi-byte sequences.
+        const buf = Buffer.allocUnsafe(byteLength);
+        const fd = openSync(filePath, "r");
+        try {
+          readSync(fd, buf, 0, byteLength, lastSize);
+        } finally {
+          closeSync(fd);
+        }
+
+        lastSize = currentSize;
+
+        const newContent = new TextDecoder().decode(buf);
+        for (const line of newContent.split("\n").filter(Boolean)) {
+          callback(line);
         }
       } catch {}
     }, 500);
@@ -138,43 +155,55 @@ export class LogManager {
       const file = Bun.file(filePath);
       if (!(await file.exists())) return;
 
-      const stat = statSync(filePath);
-      if (stat.size < options.maxSize) return;
+      // Async stat — no thread-blocking syscall on the main event loop
+      const fileStat = await stat(filePath);
+      if (fileStat.size < options.maxSize) return;
 
-      // Rotate files
+      // Rotate files: shift .N → .N+1, filePath → .1
       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 {}
+
+        const srcExists = await access(src).then(() => true).catch(() => false);
+        if (!srcExists) continue;
+
+        await rename(src, dst);
+
+        if (options.compress) {
+          // Spawn the system `gzip` binary as a background subprocess so
+          // compression never blocks the JS event loop. gzip -f replaces
+          // `dst` with `dst.gz` in-place, matching the old .gz naming.
+          try {
+            const proc = Bun.spawn(["gzip", "-f", dst], {
+              stdout: "ignore",
+              stderr: "pipe",
+            });
+            const exitCode = await proc.exited;
+            if (exitCode !== 0) {
+              const errText = await new Response(proc.stderr).text();
+              console.error(`[bm2] gzip failed for ${dst}: ${errText.trim()}`);
+            }
+          } catch (compressErr) {
+            console.error(`[bm2] Failed to compress rotated log ${dst}:`, compressErr);
           }
         }
       }
 
-      // Clean excess rotated files
+      // Clean excess rotated files asynchronously
       const dir = dirname(filePath);
       const baseName = filePath.split("/").pop()!;
       try {
-        const files = readdirSync(dir);
+        const files = await readdir(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]!));
-        }
+        await Promise.all(
+          rotated.slice(options.retain).map((f) => unlink(join(dir, f)).catch(() => {}))
+        );
       } catch {}
 
-      // Truncate original
+      // Truncate original to reclaim inode while keeping it open for writers
       await Bun.write(filePath, "");
     } catch (err) {
       console.error(`[bm2] Log rotation failed for ${filePath}:`, err);

package/src/process-container.ts

@@ -32,6 +32,9 @@ import {
   DEFAULT_LOG_MAX_SIZE,
   DEFAULT_LOG_RETAIN,
 } from "./constants";
+import pidusage from "pidusage";
+import { readdir } from "node:fs/promises";
+
 
 export class ProcessContainer {
   public id: number;
@@ -224,56 +227,90 @@ export class ProcessContainer {
 
   private async pipeStream(stream: ReadableStream<Uint8Array>, filePath: string) {
     const reader = stream.getReader();
+    const decoder = new TextDecoder();
+
+    // Holds the tail of the last chunk if it did not end on a newline.
+    // Without this, a chunk boundary mid-word (e.g. "hel" / "lo\n") would be
+    // written as two separate log lines, corrupting the output.
+    let remainder = "";
+
     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`);
+
+        if (done) {
+          // Flush any buffered content that was never terminated with \n
+          if (remainder.length > 0) {
+            const timestamp = new Date().toISOString();
+            await this.logManager.appendLog(filePath, `[${timestamp}] ${remainder}\n`);
+            remainder = "";
+          }
+          break;
         }
+
+        // stream=true tells the decoder to hold multi-byte UTF-8 sequences
+        // that straddle chunk boundaries rather than emitting replacement chars.
+        const chunk = decoder.decode(value, { stream: true });
+
+        // Prepend any leftover from the previous chunk before splitting.
+        // This is a single string allocation per chunk (not per line), so
+        // allocation pressure stays O(chunk size) rather than O(line count).
+        const text = remainder + chunk;
+        const lines = text.split("\n");
+
+        // The last element is either "" (chunk ended on \n) or an incomplete
+        // line. Either way, hold it back for the next iteration.
+        remainder = lines.pop()!;
+
+        if (lines.length === 0) continue;
+
+        const timestamp = new Date().toISOString();
+        // Build a single string for all complete lines in this chunk so
+        // appendLog (and the underlying O_APPEND write) is called once per
+        // chunk, not once per line.
+        const output = lines.map((line) => `[${timestamp}] ${line}\n`).join("");
+        await this.logManager.appendLog(filePath, output);
       }
-    } catch {}
+    } catch {
+      // Flush remainder on unexpected stream error
+      if (remainder.length > 0) {
+        const timestamp = new Date().toISOString();
+        await this.logManager.appendLog(filePath, `[${timestamp}] ${remainder}\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;
+      this.monitorInterval = setInterval(async () => {
+        
+        if (!this.pid || this.status !== "online") return;
+  
+        try {
+          
+          // 1. Fetch cross-platform CPU and Memory usage
+          const stats = await pidusage(this.pid);
+          
+          // pidusage returns memory directly in bytes and cpu as a percentage
+          this.memory = stats.memory; 
+          this.cpu = stats.cpu;
+  
+          // 2. Track file descriptors (handles) on Linux
+          // (pidusage does not provide this metric, so we keep the original logic)
+          if (process.platform === "linux") {
+            try {
+              this.handles = (await readdir(`/proc/${this.pid}/fd`)).length;
+            } catch {}
           }
-
-          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]!);
+  
+          // 3. 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();
           }
-        }
-
-        // 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);
+          
+        } catch {}
+      }, MONITOR_INTERVAL);
   }
 
   private startLogRotation(logPaths: { outFile: string; errFile: string }) {

package/src/process-manager.ts

@@ -35,7 +35,9 @@
    DEFAULT_RESTART_DELAY,
    DEFAULT_LOG_MAX_SIZE,
    DEFAULT_LOG_RETAIN,
- } from "./constants";
+} from "./constants";
+import path from "path";
+
  
  export class ProcessManager {
    private processes: Map<number, ProcessContainer> = new Map();
@@ -73,8 +75,12 @@
         const config = this.buildConfig(id, name, options, resolvedInstances, i);
         
         const container = new ProcessContainer(
-          id, config, this.logManager, this.clusterManager,
-          this.healthChecker, this.cronManager
+          id,
+          config,
+          this.logManager,
+          this.clusterManager,
+          this.healthChecker,
+          this.cronManager
         );
 
         this.processes.set(id, container);
@@ -109,10 +115,15 @@
      instances: number,
      workerIndex: number
    ): ProcessDescription {
+     
+     const script = path.isAbsolute(options.script)
+       ? options.script
+       : path.resolve(process.cwd(), options.script);
+     
      return {
        id,
        name,
-       script: options.script,
+       script,
        args: options.args || [],
        cwd: options.cwd || process.cwd(),
        env: {

package/src/process-table.ts

@@ -106,6 +106,8 @@ export function printProcessTable(processes: ProcessState[]) {
     style: { border: ["dim"] },
     chars: minimalBorders(),
   });
+  
+  //console.log("processes===>", processes)
 
   for (const p of processes) {
     const cpu = p.monit?.cpu ?? 0;
@@ -158,6 +160,7 @@ export function liveWatchProcess(processes: ProcessState[], interval = 5_000) {
   // Render table
   const render = () => {
     clear();
+    
     printProcessTable(getSortedProcesses());
     
     console.log(color("─".repeat(50), "dim"));