bm2 1.0.33 → 1.0.35

package/README.md

@@ -451,43 +451,66 @@ bm2 reset all
 
 Cluster mode spawns multiple instances of your application, each running in its own process. This is ideal for CPU-bound workloads and for taking full advantage of multi-core servers.
 
-```
+```bash
 bm2 start server.ts --name api --instances max
-```
 
 ```
+
+```bash
 bm2 start server.ts --name api --instances 4
-```
 
 ```
+
+```bash
 bm2 start server.ts --name api --instances 4 --port 3000
+
 ```
 
+#### ⚠️ Current Status & Limitations
+
+While `bm2` provides the orchestration for clustering, please note that **Bun’s native cluster implementation is currently limited by the underlying OS:**
+
+* **Linux Only:** Port sharing via `reusePort` is only fully supported on **Linux**.
+* **macOS & Windows:** Due to OS-level limitations with `SO_REUSEPORT`, these platforms ignore the `reusePort` option. On these systems, clustering may result in "Address already in use" errors if attempting to bind multiple workers to the same port.
+
+`bm2` leverages the native [Bun.serve cluster logic](https://www.google.com/search?q=https://bun.sh/docs/api/http%23cluster) to ensure maximum performance, but it remains subject to the runtime's maturity.
+
+
+#### Environment Variables
+
 Each cluster worker receives the following environment variables:
 
 | Variable | Description |
-|---|---|
+| --- | --- |
 | `BM2_CLUSTER` | Set to `"true"` in cluster mode |
 | `BM2_WORKER_ID` | Zero-indexed worker ID |
 | `BM2_INSTANCES` | Total number of instances |
 | `NODE_APP_INSTANCE` | Same as `BM2_WORKER_ID` (PM2 compatibility) |
 | `PORT` | `basePort + workerIndex` (if `--port` is specified) |
 
-Example application using cluster-aware port binding:
+---
 
-```
+#### Example: Cluster-Aware Port Binding
+
+To enable clustering in Bun, you must explicitly set `reusePort: true`. This allows multiple processes to listen on the same port (on supported OSs).
+
+```typescript
 // server.ts
 const workerId = parseInt(process.env.BM2_WORKER_ID || "0");
 const port = parseInt(process.env.PORT || "3000");
 
 Bun.serve({
   port,
+  // Share the same port across multiple processes
+  // This is the important part!
+  reusePort: true, 
   fetch(req) {
     return new Response(`Hello from worker ${workerId} on port ${port}`);
   },
 });
 
 console.log(`Worker ${workerId} listening on :${port}`);
+
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bm2",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "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/daemon.ts

@@ -35,6 +35,11 @@ const pm = new ProcessManager();
 const dashboard = new Dashboard(pm);
 const moduleManager = new ModuleManager(pm);
 
+const args = process.argv.slice(2);
+
+// Checks if '--debug' exists anywhere in the arguments
+const debugMode = args.includes('--debug');
+
 // Clean up existing socket
 if (existsSync(DAEMON_SOCKET)) {
   try { unlinkSync(DAEMON_SOCKET); } catch {}
@@ -223,8 +228,13 @@ async function handleMessage(msg: DaemonMessage): Promise<DaemonResponse> {
       default:
         return { type: "error", error: `Unknown command: ${msg.type}`, success: false, id: msg.id };
     }
-  } catch (err: any) {
-    return { type: "error", error: err.message, success: false, id: msg.id };
+  } catch (err: Error | any) {
+    let error = err.message;
+    if (debugMode) {
+      error = `Message: ${err.message}\nStack: ${err.stack}` 
+      console.error(err, err.stack)
+    }
+    return { type: "error", error, success: false, id: msg.id };
   }
 }
 

package/src/index.ts

@@ -41,6 +41,7 @@ import type {
 } from "./types";
 import { statusColor } from "./colors";
 import { liveWatchProcess, printProcessTable } from "./process-table";
+import { exists } from "fs/promises";
 
 // ---------------------------------------------------------------------------
 // Ensure directory structure exists
@@ -51,6 +52,7 @@ ensureDirs();
 // Daemon communication helpers
 // ---------------------------------------------------------------------------
 
+
 function isDaemonRunning(): boolean {
   if (!existsSync(DAEMON_PID_FILE)) return false;
   try {
@@ -98,6 +100,25 @@ async function startDaemon(): Promise<void> {
   }
 }
 
+async function stopDaemon(): Promise<void> {
+  try {
+    
+    if (!isDaemonRunning()) return;
+    
+    const pidText = await Bun.file(DAEMON_PID_FILE).text();
+    const pid = Number(pidText);
+
+    process.kill(pid, "SIGTERM"); // graceful stop
+
+    console.error("Daemon stopped");
+
+    // cleanup
+    await Bun.write(DAEMON_PID_FILE, "");
+  } catch (err) {
+    console.error("Failed to stop daemon:", err);
+  }
+}
+
 async function sendToDaemon(msg: DaemonMessage): Promise<DaemonResponse> {
     
   //start the daemon
@@ -143,8 +164,10 @@ async function sendToDaemon(msg: DaemonMessage): Promise<DaemonResponse> {
 async function loadEcosystemConfig(filePath: string): Promise<EcosystemConfig> {
   
   const abs = resolve(filePath);
+ 
+  const file = Bun.file(abs);
   
-  if (!existsSync(abs)) {
+  if (!(await file.exists())) {
     throw new Error(`Ecosystem file not found: ${abs}`);
   }
 
@@ -153,7 +176,7 @@ async function loadEcosystemConfig(filePath: string): Promise<EcosystemConfig> {
   let config;
   
   if (ext === ".json") {
-    config = (await Bun.file(abs).json()) as EcosystemConfig;
+    config = (await file.json()) as EcosystemConfig;
   } else {
     // .ts, .js, .mjs — dynamic import
     const mod = await import(abs);
@@ -362,8 +385,11 @@ async function cmdStart(args: string[]) {
   opts.script = resolve(scriptOrConfig);
   
   const cwd = path.dirname(opts.script);
-
-  const res = await sendToDaemon({ type: "start", data: { config: opts, cwd } });
+  
+  opts.cwd = cwd;
+  
+  const res = await sendToDaemon({ type: "start", data: opts });
+  
   if (!res.success) {
     console.error(colorize(`Error: ${res.error}`, "red"));
     process.exit(1);
@@ -697,7 +723,8 @@ async function cmdDeploy(args: string[]) {
     process.exit(1);
   }
 
-  const {config, cwd } = await loadEcosystemConfig(configFile);
+  const config = await loadEcosystemConfig(configFile);
+  
   if (!config.deploy || !config.deploy[environment]) {
     console.error(colorize(`Deploy environment "${environment}" not found in config`, "red"));
     process.exit(1);
@@ -846,29 +873,42 @@ async function cmdModule(args: string[]) {
 }
 
 async function cmdDaemon(args: string[]) {
+ 
+  
+  const daemonStatus = () => {
+    if (isDaemonRunning()) {
+      console.log(colorize("running", "green"));
+    } else {
+      console.error(colorize("stopped", "red"));
+    }
+    
+    process.exit(1);
+  }
+  
   const subCmd = args[0];
-  let type;
   
   switch (subCmd) {
+    case "status":
+      daemonStatus();
+      break;
+    case "start":
+      await startDaemon();
+      process.exit(1);
+      break
+    case "stop":
+      await stopDaemon();
+      process.exit(1);
+      break;
     case "reload":
-      type = "daemonReload"
+      await stopDaemon();
+      await startDaemon();
+      process.exit(1);
       break;
     default:
-      console.error(colorize("Usage: bm2 daemon <reload>", "red"));
+      console.error(colorize("Usage: bm2 daemon <status|start|stop|reload>", "red"));
       process.exit(1);
   }
-  
-  const res = await sendToDaemon({ type });
     
-  if (res?.error) {
-    console.error(colorize(`Error: ${res.error}`, "red"));
-    process.exit(1);
-  }
-  
-  console.log(colorize(res.data, "green"));
-  
-  process.exit(1);
-  
 }
 
 async function cmdPrometheus() {

package/src/process-manager.ts

@@ -66,11 +66,12 @@ import path from "path";
     options.script = path.isAbsolute(options.script) 
       ? options.script
       : path.join(options.cwd!, options.script);
-        
+    
+    
     if (!(await Bun.file(options.script).exists())) {
       throw new Error(`Script not found: ${options.script}`);
-    }
-
+    } 
+ 
     if (isCluster) {
       // In cluster mode, each instance is a separate container
       for (let i = 0; i < resolvedInstances; i++) {
@@ -94,6 +95,7 @@ import path from "path";
         await container.start();
         states.push(container.getState());
       }
+      
     } else {
       const id = this.nextId++;
       const name =
@@ -103,8 +105,11 @@ import path from "path";
   
       const config = this.buildConfig(id, name, options, 1, 0);
       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);
@@ -113,7 +118,7 @@ import path from "path";
     }
 
     return states;
-   }
+  }
  
    private buildConfig(
      id: number,