bm2 1.0.37 → 1.0.39

package/README.md

@@ -540,6 +540,8 @@ bm2 logs my-api --err
 
 ```
 bm2 logs my-api --follow
+bm2 logs my-api -f
+bm2 logs -f
 ```
 
 ---

package/package.json

@@ -1,78 +1,80 @@
 {
-  "name": "bm2",
-  "version": "1.0.37",
-  "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",
-  "types": "src/api.ts",
-  "exports": {
-    ".": "./src/api.ts",
-    "./cli": "./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": "GPL-3.0",
-  "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": {
-    "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"
-  }
+	"name": "bm2",
+	"version": "1.0.39",
+	"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",
+	"types": "src/api.ts",
+	"exports": {
+		".": "./src/api.ts",
+		"./cli": "./src/index.ts",
+		"./types": "./src/types.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": "GPL-3.0",
+	"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": {
+		"chalk": "^5.6.2",
+		"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/daemon.ts

@@ -25,7 +25,7 @@ import {
 } from "./constants";
 import { ensureDirs } from "./utils";
 import type { DaemonMessage, DaemonResponse } from "./types";
-import type { Server } from "bun";
+import type { ReadableStreamController, Server } from "bun";
 
 
 export default class Daemon {
@@ -48,6 +48,7 @@ export default class Daemon {
   getServerOpts = () => ({
     unix: DAEMON_SOCKET,
     fetch: this.boundFetch,
+    idleTimeout: 0
   });
 
   
@@ -100,6 +101,11 @@ export default class Daemon {
     try {
 
       const msg = (await req.json()) as DaemonMessage;
+      
+      if (msg.mode == "stream") {
+        return this.handleStream(msg, req);
+      }
+      
       const response = await this.handleMessage(msg);
       return Response.json(response);
 
@@ -110,6 +116,38 @@ export default class Daemon {
       );
     }
   }
+  
+  handleStream(msg: DaemonMessage, req: Request) {
+    
+    //let controller: ReadableStreamDefaultController;
+    const self = this;
+    const signal: AbortSignal = req.signal;
+    
+    const stream = new ReadableStream({
+      start(controller) {
+         
+        self.handleStreamMessage(msg, controller, signal);
+        
+        const keepAlive = setInterval(() => {
+          controller.enqueue(': ping\n\n');   // SSE comment – ignored by clients but counts as data
+        }, 5000);                  // every 5 seconds (less than 10s timeout)
+        
+        // cleanup when client disconnects
+        signal.addEventListener("abort", () => {
+          clearInterval(keepAlive)
+          controller.close();
+        });
+      },
+    });
+   
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream", // SSE style
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  }
 
   // initialize MUST be called before startServer
   startServer(): Server<any> {
@@ -118,9 +156,30 @@ export default class Daemon {
       throw new Error("Daemon.initialize() must be called before startServer()");
     }
     
-    this.server = Bun.serve(this.getServerOpts());
+    this.server = Bun.serve(this.getServerOpts() as any);
     return this.server;
   }
+  
+  async handleStreamMessage(msg: DaemonMessage, streamController: ReadableStreamDefaultController, signal: AbortSignal) {
+        
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const pm = this.pm!;
+    //const dashboard = this.dashboard!;
+    //const moduleManager = this.moduleManager!;
+    //const metricsInterval = this.metricsInterval!;
+
+    switch (msg.type) {
+      case "streamLogs": {
+        await pm.streamLogs(msg.data.target, streamController, signal);
+        break;
+      }
+      default:
+    }
+  }
+
 
   async handleMessage(msg: DaemonMessage): Promise<DaemonResponse> {
     try {
@@ -185,6 +244,7 @@ export default class Daemon {
           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 };

package/src/index.ts

@@ -38,10 +38,13 @@ import type {
   StartOptions,
   EcosystemConfig,
   ProcessState,
+  LogEntry,
+  LogItem,
 } from "./types";
 import { statusColor } from "./colors";
 import { liveWatchProcess, printProcessTable } from "./process-table";
 import Daemon from "./daemon";
+import chalk from "chalk";
 
 // ---------------------------------------------------------------------------
 // Ensure directory structure exists
@@ -163,6 +166,58 @@ class BM2CLI {
       return { type: "error", error: "Fetch Error", success: false };
     }
   }
+  
+  async getDaemonStream<T>(data: DaemonMessage, callback: (data: T | null) => void) {
+    try {
+      
+      await this.startDaemon();
+     
+       const res = await fetch("http://localhost/command", {
+         unix: DAEMON_SOCKET,
+         method: "POST",
+         headers: { "Content-Type": "application/json" },
+         body: JSON.stringify(data)
+       })
+      
+       if (!res.body) {
+        console.error("No stream received");
+        process.exit(1);
+      }
+       
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      
+      
+      let buffer = "";
+    
+      while (true) {
+        
+        const { value, done } = await reader.read();
+        
+        if (done) break;
+    
+        buffer += decoder.decode(value, { stream: true });
+    
+        // split SSE messages
+        const parts = buffer.split("\n\n");
+        buffer = parts.pop()!;
+    
+        for (const part of parts) {
+          const line = part.replace(/^data:\s*/, "").trim();
+          if (!line) continue;
+          
+          try {
+            const result = JSON.parse(line) as T;
+            callback(result)
+          } catch { }
+          
+        }
+      }
+      
+    } catch (e: any) {
+      console.log("getDaemonStream:", e, e.stack);
+    }
+  }
 
   // -------------------------------------------------------------------------
   // Ecosystem config loader
@@ -413,7 +468,7 @@ class BM2CLI {
       }
       
       printProcessTable(res.data);
-      
+            
       if (this.noDaemon) {
         await new Promise(() => {});
       }
@@ -565,31 +620,74 @@ class BM2CLI {
       console.log();
     }
   }
-
+  
   async cmdLogs(args: string[]) {
-    const target = args[0] || "all";
+    
+    let target: string | number = "all";
     let lines = 20;
-    const linesIdx = args.indexOf("--lines");
-    if (linesIdx !== -1 && args[linesIdx + 1]) {
-      lines = parseInt(args[linesIdx + 1]!);
+    let follow = false;
+  
+    let i = 0;
+  
+    while (i < args.length) {
+      const arg = args[i]!;
+  
+      if ((arg === "--lines" || arg === "-l") && !Number.isNaN(Number(args[i + 1]))) {
+        lines = parseInt(args[i + 1]!);
+        i++; // skip value
+      } else if (arg.startsWith("--lines=")) {
+        lines = parseInt(arg.split("=")[1]!);
+      } else if (arg === "--follow" || arg === "-f") {
+        follow = true;
+      } else if (!arg.startsWith("-")) {
+        target = arg;
+      }
+  
+      i++;
     }
-
-    const res = await this.sendToDaemon({ type: "logs", data: { target, lines } });
-    if (!res.success) {
-      console.error(colorize(`Error: ${res.error}`, "red"));
-      process.exit(1);
+  
+    const renderLog = (log: LogItem) => {
+      let line;
+      if (log.level == "err") {
+        line = chalk.red(`[ERROR] ${log.name} | ${log.ts}: ${log.msg}\n`)
+      } else {
+        line = chalk.white(`${chalk.cyan(`[OUTPUT] ${log.name} | ${log.ts}`)}: ${log.msg}\n`)
+      }
+      console.log(line)  
     }
-
-    for (const log of res.data) {
-      console.log(colorize(`\n─── ${log.name} (id: ${log.id}) ───`, "bold"));
-      if (log.out) {
-        console.log(colorize("--- stdout ---", "dim"));
-        console.log(log.out);
+  
+    if (follow) {
+      
+      const opts: DaemonMessage = {
+        type: "streamLogs",
+        data: { target },
+        mode: "stream"
       }
-      if (log.err) {
-        console.log(colorize("--- stderr ---", "red"));
-        console.log(log.err);
+      
+      const callback = (log: LogItem | null) => {
+        if(log) renderLog(log)
       }
+      
+      await this.getDaemonStream<LogItem>(opts, callback);
+         
+    } else {
+      
+      const res = await this.sendToDaemon({
+        type: "logs",
+        data: { target, lines },
+      });
+  
+      if (!res.success) {
+        console.error(colorize(`Error: ${res.error}`, "red"));
+        process.exit(1);
+      }
+     
+      const logs: LogItem[] = res.data ?? [];
+      
+      for (let log of logs) {
+        renderLog(log)
+      }
+      
     }
   }
 

package/src/log-manager.ts

@@ -15,12 +15,21 @@
  */
 
 import { join, dirname } from "path";
-import { openSync, readSync, closeSync } from "fs";
-import { appendFile, stat, rename, unlink, readdir, access } from "fs/promises";
+import { appendFile, rename, unlink, readdir } from "fs/promises";
 import { LOG_DIR, DEFAULT_LOG_MAX_SIZE, DEFAULT_LOG_RETAIN } from "./constants";
-import type { LogRotateOptions } from "./types";
+import type {  LogEntry, LogRotateOptions } from "./types";
+import { watch } from "fs";
+import type { ReadableStreamController } from "bun";
+import { $ } from "bun"
+import { EOL } from 'node:os';
+
+const isoRegex: RegExp = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/;
+
+// [__br__] = linebreak
+const nl = "[__br__]"
 
 export class LogManager {
+  
   private writeBuffers: Map<string, string[]> = new Map();
   private flushTimers: Map<string, ReturnType<typeof setTimeout>> = new Map();
 
@@ -30,7 +39,8 @@ export class LogManager {
       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);
 
@@ -47,6 +57,32 @@ export class LogManager {
       }, 100));
     }
   }
+  
+  async appendJSONLog(filePath: string, msg: string) {
+    
+     msg = msg.trim().replace(/[\r\n]+/g, nl);
+    
+    const log: LogEntry = {
+      ts: new Date().toISOString(),
+      msg
+    };
+  
+    const line = JSON.stringify(log) + "\n";
+  
+    // reuse your buffer system 
+    if (!this.writeBuffers.has(filePath)) {
+      this.writeBuffers.set(filePath, []);
+    }
+  
+    this.writeBuffers.get(filePath)!.push(line);
+  
+    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);
@@ -72,6 +108,32 @@ export class LogManager {
       await this.flushBuffer(filePath);
     }
   }
+  
+  private parseLine(line: string, level?: "err" | "out"): LogEntry {
+    
+    let newLine: LogEntry;
+    
+    try {
+      
+      newLine = JSON.parse(line) as LogEntry;
+      
+    } catch {
+      // fallback to old format
+      const ts = this.extractLogTs(line);
+      const msg = line.replace(`[${ts}]`, "").trim();
+      newLine = { ts, msg };
+    }
+    
+    newLine.msg = newLine.msg.replaceAll(nl, EOL)
+    newLine.level = level;
+    
+    return newLine;
+  }
+  
+  private extractLogTs(line: string) {
+    const match = line.match(isoRegex);
+    return match?.[0] ?? ""
+  }
 
   async readLogs(
     name: string,
@@ -79,135 +141,131 @@ export class LogManager {
     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 {}
+  ): Promise<LogEntry[]> {
 
-    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 {}
+    const paths = this.getLogPaths(name, id, customOut, customErr);
+    
+    const logs = (await Promise.all(Object.values(paths).map(async (fp) => {         
+      
+      const f = Bun.file(fp);
+      if (!(await f.exists())) return [];
 
-    return { out, err };
+      const level = (fp == paths.errFile) ? "err" : "out";
+      
+      const rawLog = await $`tail -n ${lines} ${fp}`.text();
+ 
+       return rawLog
+         .split("\n")
+         .filter(Boolean)
+         .map(l => this.parseLine(l, level));
+      
+    }))).flat();
+        
+    // lets sort the logs here 
+    let sortedLogs = logs
+      .sort((a, b) => (a.ts || "").localeCompare(b.ts || ""))
+    
+    if (sortedLogs.length > lines) {
+      sortedLogs = sortedLogs.slice(-lines)
+    }
+    
+    console.log(sortedLogs)
+      
+    return sortedLogs
   }
 
   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) 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);
+    name: string,
+    id: number,
+    streamController: ReadableStreamDefaultController,
+    signal: AbortSignal
+  ) {
+    const paths = this.getLogPaths(name, id);
+  
+    const state = {
+      out: Bun.file(paths.outFile).size,
+      err: Bun.file(paths.errFile).size,
+    };
+    
+  
+    const poll = setInterval(async () => {
+      for (const [type, fp] of [["out", paths.outFile],["err", paths.errFile],] as const) {
+        
+        const f = Bun.file(fp);
+  
+        if (!(await f.exists())) continue;
+  
+        let lastSize = state[type];
+  
+        const size = f.size;
+  
+        if (size < lastSize) {
+          state[type] = 0; // rotated file
+          lastSize = 0;
         }
-
-        lastSize = currentSize;
-
-        const newContent = new TextDecoder().decode(buf);
-        for (const line of newContent.split("\n").filter(Boolean)) {
-          callback(line);
+  
+        if (size === lastSize) continue;
+  
+        const chunk = await f.slice(lastSize, size).text();
+        state[type] = size;
+  
+        for (const line of chunk.split("\n").filter(Boolean)) {
+          try {
+            const log = { name, id, ...this.parseLine(line, type) };
+            streamController.enqueue(`data: ${JSON.stringify(log)}\n\n`);
+          } catch (e: any) {
+            console.log("tailLog: ", e, e.stack)
+            return;
+          }
         }
-      } catch {}
+      }
     }, 500);
+  
+    signal.addEventListener("abort", () => {
+      clearInterval(poll);
+    });
   }
 
   async rotate(filePath: string, options: LogRotateOptions): Promise<void> {
-    try {
-      const file = Bun.file(filePath);
-      if (!(await file.exists())) 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: 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}`;
-
-        const srcExists = await access(src).then(() => true).catch(() => false);
-        if (!srcExists) continue;
-
+    
+    const file = Bun.file(filePath);
+    
+    if (!(await file.exists()) || file.size < options.maxSize) return;
+  
+    const bgTasks: Promise<any>[] = [];
+  
+    for (let i = options.retain - 1; i >= 1; i--) {
+      
+      const src = i === 1 ? filePath : `${filePath}.${i - 1}`;
+      const dst = `${filePath}.${i}`;
+  
+      if (await Bun.file(src).exists()) {
+        
         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);
-          }
+          // Fire-and-forget compression doesn't block the next rename
+          bgTasks.push(Bun.spawn(["gzip", "-f", dst]).exited); 
         }
       }
-
-      // Clean excess rotated files asynchronously
-      const dir = dirname(filePath);
-      const baseName = filePath.split("/").pop()!;
-      try {
-        const files = await readdir(dir);
-        const rotated = files
-          .filter((f) => f.startsWith(baseName + "."))
-          .sort()
-          .reverse();
-        await Promise.all(
-          rotated.slice(options.retain).map((f) => unlink(join(dir, f)).catch(() => {}))
-        );
-      } catch {}
-
-      // 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);
     }
+  
+    await Bun.write(filePath, ""); // Instantly truncate and reclaim space
+  
+    const dir = dirname(filePath);
+    const baseName = filePath.split("/").pop()!;
+  
+    // Background cleanup
+    bgTasks.push(
+      readdir(dir).then(files =>
+        Promise.all(
+          files.filter(f => f.startsWith(`${baseName}.`)).sort().reverse()
+            .slice(options.retain).map(f => unlink(join(dir, f)).catch(() => {}))
+        )
+      ).catch(() => {})
+    );
+  
+    // Let Bun handle the heavy lifting in the background!
+    Promise.all(bgTasks).catch(() => {}); 
   }
 
   async flush(name: string, id: number, customOut?: string, customErr?: string) {

package/src/process-container.ts

@@ -153,11 +153,9 @@ export class ProcessContainer {
       }
     } 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`
-      );
+ 
+      await this.logManager.appendJSONLog(logPaths.errFile, `[bm2] Failed to start: ${err.message}`);
+      
       throw err;
     }
   }
@@ -229,6 +227,7 @@ export class ProcessContainer {
     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.
@@ -237,12 +236,11 @@ export class ProcessContainer {
     try {
       while (true) {
         const { done, value } = await reader.read();
-
+        
         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`);
+            await this.logManager.appendJSONLog(filePath, remainder)
             remainder = "";
           }
           break;
@@ -255,27 +253,14 @@ export class ProcessContainer {
         // 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 text = (remainder + chunk).trim();
 
-        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);
+        await this.logManager.appendJSONLog(filePath, text);
       }
     } 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(() => {});
+        await this.logManager.appendJSONLog(filePath, remainder).catch(() => {});
       }
     }
   }

package/src/process-manager.ts

@@ -19,6 +19,8 @@
    StartOptions,
    EcosystemConfig,
    MetricSnapshot,
+   LogEntry,
+   LogItem,
  } from "./types";
  import { ProcessContainer } from "./process-container";
  import { LogManager } from "./log-manager";
@@ -37,6 +39,7 @@
    DEFAULT_LOG_RETAIN,
  } from "./constants";
 import path from "path";
+import type { ReadableStreamController } from "bun";
  
  export class ProcessManager {
    private processes: Map<number, ProcessContainer> = new Map();
@@ -306,15 +309,34 @@ import path from "path";
    }
  
    async getLogs(target: string | number, lines: number = 20) {
+     
      const containers = this.resolveTarget(target);
-     const results: Array<{ name: string; id: number; out: string; err: string }> = [];
-     for (const c of containers) {
-       const logs = await this.logManager.readLogs(
-         c.name, c.id, lines, c.config.outFile, c.config.errorFile
-       );
-       results.push({ name: c.name, id: c.id, ...logs });
-     }
-     return results;
+     
+    // just for readability
+     let results: LogItem[] = [];
+          
+     results = (await Promise.all(containers.map(async (c) => {
+      const logs = await this.logManager.readLogs(c.name, c.id, lines, c.config.outFile, c.config.errorFile);     
+      return logs.map((log) => ({ name: c.name, id: c.id, ...log }))
+     }))).flat();
+     
+     
+     let sortedResults = results
+       .sort((a, b) => (a.ts || "").localeCompare(b.ts || ""))
+     
+     
+     return sortedResults;
+   }
+   
+   async streamLogs(target: string | number, streamController: ReadableStreamDefaultController, signal: AbortSignal) {
+     
+     const containers = this.resolveTarget(target);
+     const lm = this.logManager;
+     
+     await Promise.all(containers.map(async (c) => (
+      lm.tailLog(c.name, c.id, streamController, signal)
+     )))
+     
    }
  
    async flushLogs(target?: string | number) {
@@ -401,6 +423,7 @@ import path from "path";
    }
  
    private resolveTarget(target: string | number): ProcessContainer[] {
+     
      if (target === "all") {
        return Array.from(this.processes.values());
      }

package/src/types.ts

@@ -177,6 +177,7 @@ export interface DaemonMessage {
   type: string;
   data?: any;
   id?: string;
+  mode?: "stream" | "http"
 }
 
 export interface DaemonResponse {
@@ -229,3 +230,16 @@ export interface DashboardState {
   metrics: MetricSnapshot;
   logs: Record<string, { out: string; err: string }>;
 }
+
+export type LogEntry = {
+  ts: string;
+  level?: "err" | "out",
+  msg: string;
+};
+
+export interface LogItem {
+  name: string;
+  id: number;
+  ts: string;
+  msg: string; level?: "err" | "out"
+}[]