npm - bm2 - Versions diffs - 1.0.0 - Mend

bm2 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/LICENSE +674 -0
package/README.md +1591 -0
package/package.json +68 -0
package/src/cluster-manager.ts +117 -0
package/src/constants.ts +44 -0
package/src/cron-manager.ts +74 -0
package/src/daemon.ts +233 -0
package/src/dashboard-ui.ts +285 -0
package/src/dashboard.ts +203 -0
package/src/deploy.ts +188 -0
package/src/env-manager.ts +77 -0
package/src/graceful-reload.ts +71 -0
package/src/health-checker.ts +112 -0
package/src/index.ts +15 -0
package/src/log-manager.ts +201 -0
package/src/module-manager.ts +119 -0
package/src/monitor.ts +185 -0
package/src/process-container.ts +508 -0
package/src/process-manager.ts +403 -0
package/src/startup.ts +158 -0
package/src/types.ts +230 -0
package/src/utils.ts +171 -0

package/src/dashboard-ui.ts ADDED Viewed

@@ -0,0 +1,285 @@
+/**
+ * BM2 — Bun Process Manager
+ * A production-grade process manager for Bun.
+ *
+ * Features:
+ * - Fork & cluster execution modes
+ * - Auto-restart & crash recovery
+ * - Health checks & monitoring
+ * - Log management & rotation
+ * - Deployment support
+ *
+ * https://github.com/your-org/bm2
+ * License: GPL-3.0-only
+ * Author: Zak <zak@maxxpainn.com>
+ */
+ export function getDashboardHTML(): string {
+   return `<!DOCTYPE html>
+ <html lang="en">
+ <head>
+ <meta charset="UTF-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <title>BM2 Dashboard</title>
+ <style>
+   * { margin: 0; padding: 0; box-sizing: border-box; }
+   :root {
+     --bg: #0d1117; --surface: #161b22; --border: #30363d;
+     --text: #c9d1d9; --text-dim: #8b949e; --accent: #58a6ff;
+     --green: #3fb950; --red: #f85149; --yellow: #d29922;
+     --orange: #db6d28; --purple: #bc8cff;
+   }
+   body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', monospace; background: var(--bg); color: var(--text); }
+   .header { background: var(--surface); border-bottom: 1px solid var(--border); padding: 16px 24px; display: flex; align-items: center; justify-content: space-between; }
+   .header h1 { font-size: 20px; color: var(--accent); }
+   .header .meta { color: var(--text-dim); font-size: 13px; }
+   .container { max-width: 1400px; margin: 0 auto; padding: 20px; }
+   .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 16px; margin-bottom: 24px; }
+   .card { background: var(--surface); border: 1px solid var(--border); border-radius: 8px; padding: 16px; }
+   .card h3 { font-size: 13px; color: var(--text-dim); text-transform: uppercase; margin-bottom: 12px; letter-spacing: 0.5px; }
+   .stat { font-size: 28px; font-weight: 700; }
+   .stat.green { color: var(--green); }
+   .stat.red { color: var(--red); }
+   .stat.yellow { color: var(--yellow); }
+   table { width: 100%; border-collapse: collapse; }
+   th { text-align: left; padding: 10px 12px; color: var(--text-dim); font-size: 12px; text-transform: uppercase; border-bottom: 2px solid var(--border); letter-spacing: 0.5px; }
+   td { padding: 10px 12px; border-bottom: 1px solid var(--border); font-size: 14px; font-family: monospace; }
+   tr:hover td { background: rgba(88, 166, 255, 0.05); }
+   .status { display: inline-block; padding: 2px 8px; border-radius: 12px; font-size: 12px; font-weight: 600; }
+   .status.online { background: rgba(63, 185, 80, 0.15); color: var(--green); }
+   .status.stopped { background: rgba(139, 148, 158, 0.15); color: var(--text-dim); }
+   .status.errored { background: rgba(248, 81, 73, 0.15); color: var(--red); }
+   .status.launching, .status.waiting-restart { background: rgba(210, 153, 34, 0.15); color: var(--yellow); }
+   .btn { padding: 6px 12px; border: 1px solid var(--border); border-radius: 6px; background: var(--surface); color: var(--text); cursor: pointer; font-size: 12px; transition: all 0.2s; }
+   .btn:hover { border-color: var(--accent); color: var(--accent); }
+   .btn.danger:hover { border-color: var(--red); color: var(--red); }
+   .btn.success:hover { border-color: var(--green); color: var(--green); }
+   .actions { display: flex; gap: 6px; }
+   .chart-container { height: 200px; position: relative; background: var(--surface); border: 1px solid var(--border); border-radius: 8px; padding: 16px; margin-bottom: 24px; }
+   .chart-title { font-size: 13px; color: var(--text-dim); text-transform: uppercase; margin-bottom: 8px; }
+   canvas { width: 100% !important; height: 160px !important; }
+   .logs-panel { background: var(--surface); border: 1px solid var(--border); border-radius: 8px; padding: 16px; margin-bottom: 24px; }
+   .logs-panel h3 { font-size: 13px; color: var(--text-dim); text-transform: uppercase; margin-bottom: 12px; }
+   .log-output { background: #000; border-radius: 4px; padding: 12px; font-family: monospace; font-size: 12px; max-height: 400px; overflow-y: auto; white-space: pre-wrap; word-break: break-all; color: var(--text); }
+   .log-output .err { color: var(--red); }
+   .log-output .timestamp { color: var(--text-dim); }
+   .tabs { display: flex; gap: 0; margin-bottom: 16px; }
+   .tab { padding: 8px 16px; background: var(--surface); border: 1px solid var(--border); cursor: pointer; font-size: 13px; color: var(--text-dim); transition: all 0.2s; }
+   .tab:first-child { border-radius: 6px 0 0 6px; }
+   .tab:last-child { border-radius: 0 6px 6px 0; }
+   .tab.active { background: var(--accent); color: #fff; border-color: var(--accent); }
+   .system-info { display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; }
+   .sys-stat { text-align: center; }
+   .sys-stat .label { font-size: 11px; color: var(--text-dim); text-transform: uppercase; }
+   .sys-stat .value { font-size: 18px; font-weight: 600; margin-top: 4px; }
+   .progress-bar { height: 6px; background: var(--border); border-radius: 3px; margin-top: 6px; overflow: hidden; }
+   .progress-bar .fill { height: 100%; border-radius: 3px; transition: width 0.5s; }
+   @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.5; } }
+   .live-indicator { display: inline-block; width: 8px; height: 8px; background: var(--green); border-radius: 50%; margin-right: 8px; animation: pulse 2s infinite; }
+ </style>
+ </head>
+ <body>
+ <div class="header">
+   <h1>⚡ BM2 Dashboard</h1>
+   <div class="meta"><span class="live-indicator"></span>Live • <span id="update-time">-</span></div>
+ </div>
+ <div class="container">
+   <div class="grid" id="stats-grid"></div>
+   <div class="chart-container">
+     <div class="chart-title">CPU & Memory Over Time</div>
+     <canvas id="chart"></canvas>
+   </div>
+   <div class="card" style="margin-bottom: 24px;">
+     <h3>System</h3>
+     <div class="system-info" id="system-info"></div>
+   </div>
+   <div class="card" style="margin-bottom: 24px;">
+     <h3>Processes</h3>
+     <table>
+       <thead>
+         <tr>
+           <th>ID</th><th>Name</th><th>Status</th><th>PID</th>
+           <th>CPU</th><th>Memory</th><th>Restarts</th><th>Uptime</th>
+           <th>Actions</th>
+         </tr>
+       </thead>
+       <tbody id="process-table"></tbody>
+     </table>
+   </div>
+   <div class="logs-panel">
+     <h3>Logs</h3>
+     <div class="tabs" id="log-tabs"></div>
+     <div class="log-output" id="log-output">Select a process to view logs</div>
+   </div>
+ </div>
+ <script>
+ const WS_URL = location.origin.replace('http','ws') + '/ws';
+ let ws;
+ let chartData = { labels: [], cpu: [], memory: [] };
+ let selectedLogProcess = null;
+ function formatBytes(b) {
+   if (!b) return '0 B';
+   const u = ['B','KB','MB','GB'];
+   const i = Math.floor(Math.log(b)/Math.log(1024));
+   return (b/Math.pow(1024,i)).toFixed(1)+' '+u[i];
+ }
+ function formatUptime(ms) {
+   const s = Math.floor(ms/1000), m = Math.floor(s/60), h = Math.floor(m/60), d = Math.floor(h/24);
+   if (d>0) return d+'d '+h%24+'h';
+   if (h>0) return h+'h '+m%60+'m';
+   if (m>0) return m+'m '+s%60+'s';
+   return s+'s';
+ }
+ function connect() {
+   ws = new WebSocket(WS_URL);
+   ws.onmessage = (e) => {
+     const data = JSON.parse(e.data);
+     if (data.type === 'state') render(data.data);
+     if (data.type === 'logs') renderLogs(data.data);
+   };
+   ws.onclose = () => setTimeout(connect, 2000);
+   ws.onerror = () => ws.close();
+ }
+ function send(type, data) { ws?.send(JSON.stringify({type,data})); }
+ function render(state) {
+   const { processes, metrics } = state;
+   document.getElementById('update-time').textContent = new Date().toLocaleTimeString();
+   // Stats cards
+   const online = processes.filter(p => p.status==='online').length;
+   const errored = processes.filter(p => p.status==='errored').length;
+   const totalMem = processes.reduce((s,p) => s+p.monit.memory, 0);
+   const totalCpu = processes.reduce((s,p) => s+p.monit.cpu, 0);
+   document.getElementById('stats-grid').innerHTML = \`
+     <div class="card"><h3>Online</h3><div class="stat green">\${online}</div></div>
+     <div class="card"><h3>Errored</h3><div class="stat red">\${errored}</div></div>
+     <div class="card"><h3>Total CPU</h3><div class="stat">\${totalCpu.toFixed(1)}%</div></div>
+     <div class="card"><h3>Total Memory</h3><div class="stat">\${formatBytes(totalMem)}</div></div>
+   \`;
+   // System info
+   if (metrics?.system) {
+     const sys = metrics.system;
+     const memPct = ((sys.totalMemory - sys.freeMemory) / sys.totalMemory * 100).toFixed(1);
+     document.getElementById('system-info').innerHTML = \`
+       <div class="sys-stat"><div class="label">Platform</div><div class="value">\${sys.platform}</div></div>
+       <div class="sys-stat"><div class="label">CPUs</div><div class="value">\${sys.cpuCount}</div></div>
+       <div class="sys-stat"><div class="label">Load (1m)</div><div class="value">\${sys.loadAvg[0].toFixed(2)}</div></div>
+       <div class="sys-stat">
+         <div class="label">Memory</div><div class="value">\${memPct}%</div>
+         <div class="progress-bar"><div class="fill" style="width:\${memPct}%;background:\${memPct>80?'var(--red)':memPct>60?'var(--yellow)':'var(--green)'}"></div></div>
+       </div>
+     \`;
+   }
+   // Chart data
+   const now = new Date().toLocaleTimeString();
+   chartData.labels.push(now);
+   chartData.cpu.push(totalCpu);
+   chartData.memory.push(totalMem / 1024 / 1024);
+   if (chartData.labels.length > 60) {
+     chartData.labels.shift(); chartData.cpu.shift(); chartData.memory.shift();
+   }
+   drawChart();
+   // Process table
+   document.getElementById('process-table').innerHTML = processes.map(p => \`
+     <tr>
+       <td>\${p.pm_id}</td>
+       <td>\${p.name}</td>
+       <td><span class="status \${p.status}">\${p.status}</span></td>
+       <td>\${p.pid||'-'}</td>
+       <td>\${p.monit.cpu.toFixed(1)}%</td>
+       <td>\${formatBytes(p.monit.memory)}</td>
+       <td>\${p.pm2_env.restart_time}</td>
+       <td>\${p.status==='online' ? formatUptime(Date.now()-p.pm2_env.pm_uptime) : '-'}</td>
+       <td class="actions">
+         <button class="btn success" onclick="send('restart',{target:'\${p.pm_id}'})">↻</button>
+         <button class="btn danger" onclick="send('stop',{target:'\${p.pm_id}'})">■</button>
+         <button class="btn" onclick="viewLogs(\${p.pm_id},'\${p.name}')">📋</button>
+       </td>
+     </tr>
+   \`).join('');
+   // Log tabs
+   document.getElementById('log-tabs').innerHTML = processes.map(p => \`
+     <div class="tab \${selectedLogProcess===p.pm_id?'active':''}" onclick="viewLogs(\${p.pm_id},'\${p.name}')">\${p.name}</div>
+   \`).join('');
+ }
+ function viewLogs(id, name) {
+   selectedLogProcess = id;
+   send('getLogs', { target: id, lines: 50 });
+ }
+ function renderLogs(logs) {
+   if (!logs || !logs.length) return;
+   const el = document.getElementById('log-output');
+   let html = '';
+   for (const log of logs) {
+     if (log.out) html += log.out.split('\\n').map(l => {
+       const m = l.match(/^\\[([^\\]]+)\\]/);
+       return m ? '<span class="timestamp">['+m[1]+']</span>'+l.slice(m[0].length) : l;
+     }).join('\\n');
+     if (log.err) html += log.err.split('\\n').map(l => '<span class="err">'+l+'</span>').join('\\n');
+   }
+   el.innerHTML = html || 'No logs available';
+   el.scrollTop = el.scrollHeight;
+ }
+ function drawChart() {
+   const canvas = document.getElementById('chart');
+   const ctx = canvas.getContext('2d');
+   const w = canvas.offsetWidth, h = 160;
+   canvas.width = w * 2; canvas.height = h * 2;
+   ctx.scale(2, 2);
+   ctx.clearRect(0, 0, w, h);
+   const len = chartData.labels.length;
+   if (len < 2) return;
+   const maxCpu = Math.max(...chartData.cpu, 1);
+   const maxMem = Math.max(...chartData.memory, 1);
+   const stepX = w / (len - 1);
+   // Grid
+   ctx.strokeStyle = '#30363d'; ctx.lineWidth = 0.5;
+   for (let i = 0; i < 4; i++) {
+     const y = h * i / 4;
+     ctx.beginPath(); ctx.moveTo(0, y); ctx.lineTo(w, y); ctx.stroke();
+   }
+   // CPU line
+   ctx.strokeStyle = '#58a6ff'; ctx.lineWidth = 2;
+   ctx.beginPath();
+   chartData.cpu.forEach((v, i) => {
+     const x = i * stepX, y = h - (v / maxCpu) * (h - 20);
+     i === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y);
+   });
+   ctx.stroke();
+   // Memory line
+   ctx.strokeStyle = '#3fb950'; ctx.lineWidth = 2;
+   ctx.beginPath();
+   chartData.memory.forEach((v, i) => {
+     const x = i * stepX, y = h - (v / maxMem) * (h - 20);
+     i === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y);
+   });
+   ctx.stroke();
+   // Legend
+   ctx.font = '11px monospace';
+   ctx.fillStyle = '#58a6ff'; ctx.fillText('● CPU ' + chartData.cpu[len-1]?.toFixed(1) + '%', 10, 14);
+   ctx.fillStyle = '#3fb950'; ctx.fillText('● MEM ' + chartData.memory[len-1]?.toFixed(1) + 'MB', 120, 14);
+ }
+ connect();
+ setInterval(() => { if (ws?.readyState === 1) send('getState', {}); }, 2000);
+ </script>
+ </body>
+ </html>`;
+ }

package/src/dashboard.ts ADDED Viewed

@@ -0,0 +1,203 @@
+/**
+ * BM2 — Bun Process Manager
+ * A production-grade process manager for Bun.
+ *
+ * Features:
+ * - Fork & cluster execution modes
+ * - Auto-restart & crash recovery
+ * - Health checks & monitoring
+ * - Log management & rotation
+ * - Deployment support
+ *
+ * https://github.com/your-org/bm2
+ * License: GPL-3.0-only
+ * Author: Zak <zak@maxxpainn.com>
+ */
+import { ProcessManager } from "./process-manager";
+import { getDashboardHTML } from "./dashboard-ui";
+import { DASHBOARD_PORT, METRICS_PORT } from "./constants";
+import type { Server, ServerWebSocket } from "bun";
+export class Dashboard {
+  private server: Server<unknown> | null = null;
+  private metricsServer: Server<unknown> | null = null;
+  private clients: Set<ServerWebSocket<unknown>> = new Set();
+  private pm: ProcessManager;
+  private updateInterval: ReturnType<typeof setInterval> | null = null;
+  constructor(pm: ProcessManager) {
+    this.pm = pm;
+  }
+  start(port: number = DASHBOARD_PORT, metricsPort: number = METRICS_PORT) {
+    // Dashboard + WebSocket server
+    this.server = Bun.serve<unknown>({
+      port,
+      fetch: (req, server) => {
+        const url = new URL(req.url);
+        if (url.pathname === "/ws") {
+          if (server.upgrade(req, { data: undefined })) return;
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+        if (url.pathname === "/api/processes") {
+          return Response.json(this.pm.list());
+        }
+        if (url.pathname === "/api/metrics") {
+          const metrics = this.pm.monitor.getLatest();
+          return Response.json(metrics);
+        }
+        if (url.pathname === "/api/metrics/history") {
+          const seconds = parseInt(url.searchParams.get("seconds") || "300");
+          return Response.json(this.pm.getMetricsHistory(seconds));
+        }
+        if (url.pathname === "/api/prometheus" || url.pathname === "/metrics") {
+          return new Response(this.pm.getPrometheusMetrics(), {
+            headers: { "Content-Type": "text/plain; charset=utf-8" },
+          });
+        }
+        // Action endpoints
+        if (req.method === "POST") {
+          return this.handleAction(url.pathname, req);
+        }
+        // Serve dashboard HTML
+        return new Response(getDashboardHTML(), {
+          headers: { "Content-Type": "text/html" },
+        });
+      },
+      websocket: {
+        open: (ws) => {
+          this.clients.add(ws);
+          // Send initial state
+          const state = {
+            processes: this.pm.list(),
+            metrics: this.pm.monitor.getLatest(),
+          };
+          ws.send(JSON.stringify({ type: "state", data: state }));
+        },
+        message: async (ws, message) => {
+          try {
+            const msg = JSON.parse(String(message));
+            await this.handleWsMessage(ws, msg);
+          } catch {}
+        },
+        close: (ws) => {
+          this.clients.delete(ws);
+        },
+      },
+    });
+    // Separate Prometheus metrics server
+    this.metricsServer = Bun.serve({
+      port: metricsPort,
+      fetch: (req) => {
+        const url = new URL(req.url);
+        if (url.pathname === "/metrics") {
+          return new Response(this.pm.getPrometheusMetrics(), {
+            headers: { "Content-Type": "text/plain; charset=utf-8" },
+          });
+        }
+        return new Response("BM2 Metrics Server\nGET /metrics for Prometheus format", {
+          status: 200,
+        });
+      },
+    });
+    // Periodic broadcast
+    this.updateInterval = setInterval(async () => {
+      await this.pm.getMetrics(); // Collect snapshot
+      this.broadcast();
+    }, 2000);
+    console.log(`[bm2] Dashboard running at http://localhost:${port}`);
+    console.log(`[bm2] Prometheus metrics at http://localhost:${metricsPort}/metrics`);
+  }
+  private async handleAction(pathname: string, req: Request): Promise<Response> {
+    try {
+        const body = (await req.json()) as { target?: string; count?: number };
+      switch (pathname) {
+        case "/api/restart":
+          return Response.json(await this.pm.restart(body.target || "all"));
+        case "/api/stop":
+          return Response.json(await this.pm.stop(body.target || "all"));
+        case "/api/reload":
+          return Response.json(await this.pm.reload(body.target || "all"));
+        case "/api/delete":
+          return Response.json(await this.pm.del(body.target!));
+        case "/api/scale":
+          return Response.json(await this.pm.scale(body.target!, body.count!));
+        case "/api/flush":
+          await this.pm.flushLogs(body.target);
+          return Response.json({ success: true });
+        default:
+          return new Response("Not Found", { status: 404 });
+      }
+    } catch (err: any) {
+      return Response.json({ error: err.message }, { status: 500 });
+    }
+  }
+  private async handleWsMessage(ws: ServerWebSocket<unknown>, msg: any) {
+    switch (msg.type) {
+      case "getState": {
+        const state = {
+          processes: this.pm.list(),
+          metrics: this.pm.monitor.getLatest(),
+        };
+        ws.send(JSON.stringify({ type: "state", data: state }));
+        break;
+      }
+      case "getLogs": {
+        const logs = await this.pm.getLogs(msg.data.target, msg.data.lines || 50);
+        ws.send(JSON.stringify({ type: "logs", data: logs }));
+        break;
+      }
+      case "restart":
+        await this.pm.restart(msg.data.target);
+        break;
+      case "stop":
+        await this.pm.stop(msg.data.target);
+        break;
+      case "reload":
+        await this.pm.reload(msg.data.target);
+        break;
+      case "scale":
+        await this.pm.scale(msg.data.target, msg.data.count);
+        break;
+    }
+  }
+  private broadcast() {
+    const state = {
+      processes: this.pm.list(),
+      metrics: this.pm.monitor.getLatest(),
+    };
+    const message = JSON.stringify({ type: "state", data: state });
+    for (const client of this.clients) {
+      try {
+        client.send(message);
+      } catch {
+        this.clients.delete(client);
+      }
+    }
+  }
+  stop() {
+    if (this.updateInterval) clearInterval(this.updateInterval);
+    if (this.server) this.server.stop();
+    if (this.metricsServer) this.metricsServer.stop();
+    this.clients.clear();
+  }
+}

package/src/deploy.ts ADDED Viewed

@@ -0,0 +1,188 @@
+/**
+ * BM2 — Bun Process Manager
+ * A production-grade process manager for Bun.
+ *
+ * Features:
+ * - Fork & cluster execution modes
+ * - Auto-restart & crash recovery
+ * - Health checks & monitoring
+ * - Log management & rotation
+ * - Deployment support
+ *
+ * https://github.com/your-org/bm2
+ * License: GPL-3.0-only
+ * Author: Zak <zak@maxxpainn.com>
+ */
+ import type { DeployConfig } from "./types";
+ export class DeployManager {
+   async deploy(config: DeployConfig, command?: string): Promise<void> {
+     const hosts = Array.isArray(config.host) ? config.host : [config.host];
+     const sshOpts = config.ssh_options || "";
+     for (const host of hosts) {
+       const target = `${config.user}@${host}`;
+       console.log(`\n[bm2] Deploying to ${target}...`);
+       const remotePath = config.path;
+       const currentPath = `${remotePath}/current`;
+       const sourcePath = `${remotePath}/source`;
+       // Pre-deploy hook
+       if (config.preDeploy) {
+         console.log(`[bm2] Running pre-deploy: ${config.preDeploy}`);
+         await this.localExec(config.preDeploy);
+       }
+       // Setup directory structure
+       await this.remoteExec(
+         target,
+         `mkdir -p ${remotePath} ${sourcePath}`,
+         sshOpts
+       );
+       // Clone or pull
+       const hasRepo = await this.remoteExec(
+         target,
+         `test -d ${sourcePath}/.git && echo "yes" || echo "no"`,
+         sshOpts
+       );
+       if (hasRepo.trim() === "yes") {
+         await this.remoteExec(
+           target,
+           `cd ${sourcePath} && git fetch --all && git reset --hard ${config.ref}`,
+           sshOpts
+         );
+       } else {
+         await this.remoteExec(
+           target,
+           `git clone ${config.repo} ${sourcePath} && cd ${sourcePath} && git checkout ${config.ref}`,
+           sshOpts
+         );
+       }
+       // Create release
+       const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+       const releasePath = `${remotePath}/releases/${timestamp}`;
+       await this.remoteExec(
+         target,
+         `mkdir -p ${remotePath}/releases && cp -r ${sourcePath} ${releasePath}`,
+         sshOpts
+       );
+       // Symlink current
+       await this.remoteExec(
+         target,
+         `rm -f ${currentPath} && ln -s ${releasePath} ${currentPath}`,
+         sshOpts
+       );
+       // Post-deploy hook
+       if (config.postDeploy) {
+         console.log(`[bm2] Running post-deploy: ${config.postDeploy}`);
+         const envStr = config.env
+           ? Object.entries(config.env)
+               .map(([k, v]) => `${k}=${v}`)
+               .join(" ")
+           : "";
+         await this.remoteExec(
+           target,
+           `cd ${currentPath} && ${envStr} ${config.postDeploy}`,
+           sshOpts
+         );
+       }
+       // Cleanup old releases (keep last 5)
+       await this.remoteExec(
+         target,
+         `cd ${remotePath}/releases && ls -dt */ | tail -n +6 | xargs rm -rf`,
+         sshOpts
+       );
+       console.log(`[bm2] ✓ Deploy to ${target} complete`);
+     }
+   }
+   async setup(config: DeployConfig): Promise<void> {
+     const hosts = Array.isArray(config.host) ? config.host : [config.host];
+     const sshOpts = config.ssh_options || "";
+     for (const host of hosts) {
+       const target = `${config.user}@${host}`;
+       console.log(`[bm2] Setting up ${target}...`);
+       await this.remoteExec(
+         target,
+         `mkdir -p ${config.path} ${config.path}/releases ${config.path}/source ${config.path}/shared`,
+         sshOpts
+       );
+       if (config.preSetup) {
+         await this.remoteExec(target, config.preSetup, sshOpts);
+       }
+       // Clone repo
+       await this.remoteExec(
+         target,
+         `git clone ${config.repo} ${config.path}/source && cd ${config.path}/source && git checkout ${config.ref}`,
+         sshOpts
+       );
+       if (config.postSetup) {
+         await this.remoteExec(
+           target,
+           `cd ${config.path}/source && ${config.postSetup}`,
+           sshOpts
+         );
+       }
+       console.log(`[bm2] ✓ Setup complete for ${target}`);
+     }
+   }
+   private async remoteExec(target: string, command: string, sshOpts: string): Promise<string> {
+     const args = ["ssh"];
+     if (sshOpts) args.push(...sshOpts.split(" "));
+     args.push(target, command);
+     const proc = Bun.spawn(args, {
+       stdout: "pipe",
+       stderr: "pipe",
+     });
+     const stdout = await new Response(proc.stdout).text();
+     const stderr = await new Response(proc.stderr).text();
+     const exitCode = await proc.exited;
+     if (exitCode !== 0 && stderr) {
+       console.error(`[bm2] Remote error: ${stderr}`);
+     }
+     if (stdout.trim()) {
+       console.log(stdout.trim());
+     }
+     return stdout;
+   }
+   private async localExec(command: string): Promise<string> {
+     const proc = Bun.spawn(["sh", "-c", command], {
+       stdout: "pipe",
+       stderr: "pipe",
+     });
+     const stdout = await new Response(proc.stdout).text();
+     const stderr = await new Response(proc.stderr).text();
+     const exitCode = await proc.exited;
+     if (exitCode !== 0 && stderr) {
+       console.error(`[bm2] Local error: ${stderr}`);
+     }
+     if (stdout.trim()) {
+       console.log(stdout.trim());
+     }
+     return stdout;
+   }
+ }