bm2 1.0.1 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bm2",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "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/index.ts",
   "module": "src/index.ts",
@@ -59,9 +59,12 @@
     "linux",
     "darwin"
   ],
-  "dependencies": {},
+  "dependencies": {
+    "ws": "^8.19.0"
+  },
   "devDependencies": {
     "@types/bun": "^1.3.9",
+    "@types/ws": "^8.18.1",
     "bun-types": "latest",
     "typescript": "^5.9.3"
   }

package/src/constants.ts

@@ -23,6 +23,8 @@ export const VERSION = "1.0.0";
 export const BM2_HOME = join(homedir(), ".bm2");
 export const DAEMON_SOCKET = join(BM2_HOME, "daemon.sock");
 export const DAEMON_PID_FILE = join(BM2_HOME, "daemon.pid");
+export const DAEMON_OUT_LOG_FILE = join(BM2_HOME, "daemon.out.log");
+export const DAEMON_ERR_LOG_FILE = join(BM2_HOME, "daemon.err.log");
 export const LOG_DIR = join(BM2_HOME, "logs");
 export const PID_DIR = join(BM2_HOME, "pids");
 export const DUMP_FILE = join(BM2_HOME, "dump.json");

package/src/daemon.ts

@@ -51,6 +51,7 @@ const metricsInterval = setInterval(() => {
 }, 2000);
 
 async function handleMessage(msg: DaemonMessage): Promise<DaemonResponse> {
+    console.log("msg.type===>", msg)
   try {
     switch (msg.type) {
       case "start": {
@@ -183,51 +184,33 @@ async function handleMessage(msg: DaemonMessage): Promise<DaemonResponse> {
   }
 }
 
-// Unix socket server
-const server = Bun.serve({
-  unix: DAEMON_SOCKET,
-  fetch(req, server) {
-    if (server.upgrade(req)) return;
-    return new Response("bm2 daemon");
-  },
-  websocket: {
-    async message(ws: ServerWebSocket<unknown>, message) {
-      try {
-        const msg: DaemonMessage = JSON.parse(String(message));
-        const response = await handleMessage(msg);
-        ws.send(JSON.stringify(response));
-      } catch (err: any) {
-        ws.send(JSON.stringify({ type: "error", error: err.message, success: false }));
-      }
-    },
-    open(ws) {},
-    close(ws) {},
-  },
-});
-
-// Signal handlers
-const shutdown = async () => {
-  console.log("\n[bm2] Shutting down daemon...");
-  await pm.stopAll();
-  dashboard.stop();
-  clearInterval(metricsInterval);
-  try { unlinkSync(DAEMON_SOCKET); } catch {}
-  try { unlinkSync(DAEMON_PID_FILE); } catch {}
-  process.exit(0);
-};
-
-process.on("SIGTERM", shutdown);
-process.on("SIGINT", shutdown);
-process.on("SIGHUP", shutdown);
 
-// Handle uncaught errors to keep daemon alive
-process.on("uncaughtException", (err) => {
-  console.error("[bm2] Uncaught exception:", err);
-});
+const server = Bun.serve({
+    unix: DAEMON_SOCKET,
+    async fetch(req) {
+                 
+        if (req.method !== "POST") {
+            return Response.json(
+                { type: "error", error: "Method Not Allowed", success: false },
+                { status: 405 }
+            )
+        }
 
-process.on("unhandledRejection", (err) => {
-  console.error("[bm2] Unhandled rejection:", err);
+        try {
+            
+            const msg: DaemonMessage = await req.json() as DaemonMessage;
+                                    
+            const response = await handleMessage(msg);
+            
+            return Response.json(response);
+            
+        } catch (err: any) {
+            return Response.json(
+                { type: "error", error: err.message, success: false },
+                { status: 500 }
+            );
+        }
+    },
 });
 
-console.log(`[bm2] Daemon running (PID: ${process.pid})`);
-console.log(`[bm2] Socket: ${DAEMON_SOCKET}`);
+console.log(`Listening on ${server.url}`);

package/src/hello.js

@@ -0,0 +1,2 @@
+
+console.log("Hello ===>")

package/src/index.ts

@@ -25,6 +25,7 @@ import {
   BM2_HOME,
   DASHBOARD_PORT,
   METRICS_PORT,
+  DAEMON_OUT_LOG_FILE,
 } from "./constants";
 import { ensureDirs, formatBytes, formatUptime, colorize, padRight } from "./utils";
 import { DeployManager } from "./deploy";
@@ -65,9 +66,9 @@ async function startDaemon(): Promise<void> {
   const bunPath = Bun.which("bun") || "bun";
 
   const child = Bun.spawn([bunPath, "run", daemonScript], {
-    stdout: "ignore",
-    stderr: "ignore",
-    stdin: "ignore",
+    stdout: Bun.file(DAEMON_OUT_LOG_FILE),
+    stderr: Bun.file(DAEMON_OUT_LOG_FILE),
+    stdin:  "ignore",
   });
 
   // Detach so the daemon outlives the CLI
@@ -83,46 +84,25 @@ async function startDaemon(): Promise<void> {
 }
 
 async function sendToDaemon(msg: DaemonMessage): Promise<DaemonResponse> {
-  await startDaemon();
-
-  return new Promise((resolvePromise, reject) => {
-    const id = crypto.randomUUID();
-    msg.id = id;
-
-    const timeout = setTimeout(() => {
-      reject(new Error("Daemon response timed out"));
-    }, 30_000);
-
-    const ws = new WebSocket(`ws+unix://${DAEMON_SOCKET}`);
-
-    ws.onopen = () => {
-      ws.send(JSON.stringify(msg));
-    };
-
-    ws.onmessage = (event) => {
-      try {
-        const res: DaemonResponse = JSON.parse(String(event.data));
-        if (res.id === id || !res.id) {
-          clearTimeout(timeout);
-          ws.close();
-          resolvePromise(res);
-        }
-      } catch (err: any) {
-        clearTimeout(timeout);
-        ws.close();
-        reject(err);
-      }
-    };
-
-    ws.onerror = (err) => {
-      clearTimeout(timeout);
-      reject(new Error(`WebSocket error: ${err}`));
-    };
-
-    ws.onclose = () => {
-      clearTimeout(timeout);
-    };
-  });
+    
+    await startDaemon();
+  
+    const res = await fetch("http://localhost/command", {
+        unix: DAEMON_SOCKET,
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(msg),
+    });
+    
+    if (!res.ok) {
+        throw new Error(`Daemon error: ${res.status}`);
+    }
+    
+    const resJson: DaemonResponse = await res.json() as DaemonResponse;
+    
+    return resJson;
 }
 
 // ---------------------------------------------------------------------------

package/src/process-manager.ts

@@ -57,49 +57,49 @@
    }
  
    async start(options: StartOptions): Promise<ProcessState[]> {
-     const resolvedInstances = this.clusterManager.resolveInstances(options.instances);
-     const isCluster = options.execMode === "cluster" || resolvedInstances > 1;
-     const states: ProcessState[] = [];
- 
-     if (isCluster) {
-       // In cluster mode, each instance is a separate container
-       for (let i = 0; i < resolvedInstances; i++) {
-         const id = this.nextId++;
-         const baseName =
-           options.name ||
-           options.script.split("/").pop()?.replace(/\.\w+$/, "") ||
-           `app-${id}`;
-         const name = resolvedInstances > 1 ? `${baseName}-${i}` : baseName;
- 
-         const config = this.buildConfig(id, name, options, resolvedInstances, i);
-         const container = new ProcessContainer(
-           id, config, this.logManager, this.clusterManager,
-           this.healthChecker, this.cronManager
-         );
- 
-         this.processes.set(id, container);
-         await container.start();
-         states.push(container.getState());
-       }
-     } else {
-       const id = this.nextId++;
-       const name =
-         options.name ||
-         options.script.split("/").pop()?.replace(/\.\w+$/, "") ||
-         `app-${id}`;
- 
-       const config = this.buildConfig(id, name, options, 1, 0);
-       const container = new ProcessContainer(
-         id, config, this.logManager, this.clusterManager,
-         this.healthChecker, this.cronManager
-       );
- 
-       this.processes.set(id, container);
-       await container.start();
-       states.push(container.getState());
-     }
- 
-     return states;
+               
+        const resolvedInstances = this.clusterManager.resolveInstances(options.instances);
+        const isCluster = options.execMode === "cluster" || resolvedInstances > 1;
+        const states: ProcessState[] = [];
+ 
+        if (isCluster) {
+            // In cluster mode, each instance is a separate container
+            for (let i = 0; i < resolvedInstances; i++) {
+                
+                const id = this.nextId++;
+                const baseName = options.name || options.script.split("/").pop()?.replace(/\.\w+$/, "") || `app-${id}`;
+                const name = resolvedInstances > 1 ? `${baseName}-${i}` : baseName;
+        
+                const config = this.buildConfig(id, name, options, resolvedInstances, i);
+                
+                const container = new ProcessContainer(
+                    id, config, this.logManager, this.clusterManager,
+                    this.healthChecker, this.cronManager
+                );
+        
+                this.processes.set(id, container);
+                await container.start();
+                states.push(container.getState());
+            }
+        } else {
+            const id = this.nextId++;
+            const name =
+                options.name ||
+                options.script.split("/").pop()?.replace(/\.\w+$/, "") ||
+                `app-${id}`;
+        
+            const config = this.buildConfig(id, name, options, 1, 0);
+            const container = new ProcessContainer(
+                id, config, this.logManager, this.clusterManager,
+                this.healthChecker, this.cronManager
+            );
+        
+            this.processes.set(id, container);
+            await container.start();
+            states.push(container.getState());
+        }
+    
+        return states;
    }
  
    private buildConfig(