bm2 1.0.24 → 1.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bm2",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "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",

package/src/cluster-manager.ts

@@ -13,11 +13,12 @@
  * License: GPL-3.0-only
  * Author: Zak <zak@maxxpainn.com>
  */
- import type { Subprocess } from "bun";
- import type { ProcessDescription } from "./types";
- import { getCpuCount } from "./utils";
+import type { Subprocess } from "bun";
+import type { ProcessDescription } from "./types";
+import { getCpuCount } from "./utils";
+import path from "path"
  
- export class ClusterManager {
+export class ClusterManager {
    private workers: Map<number, Map<number, Subprocess>> = new Map();
  
    resolveInstances(instances: number | string | undefined): number {
@@ -67,7 +68,7 @@
        cmd.push(...config.nodeArgs);
      }
  
-     cmd.push(config.script);
+     cmd.push(path.resolve(config.script));
      if (config.args?.length) cmd.push(...config.args);
  
      return cmd;

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

@@ -227,18 +227,57 @@ 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(() => {});
+      }
+    }
   }
 
   

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: {