bgrun 3.7.0 → 3.7.1

package/README.md

@@ -1,8 +1,8 @@
 <div align="center">
 
-# ⚡ bgrun
+<img src="./image.png" alt="bgrun" width="600" />
 
-**Bun Background Runner — a modern process manager built on Bun**
+**Production-ready process manager with dashboard and programmatic API, designed for running your containers, services, and AI agents.**
 
 [![npm](https://img.shields.io/npm/v/bgrun?color=F7A41D&label=npm&logo=npm)](https://www.npmjs.com/package/bgrun)
 [![bun](https://img.shields.io/badge/runtime-bun-F7A41D?logo=bun)](https://bun.sh/)
@@ -58,6 +58,29 @@ That's it. bgrun tracks the PID, captures stdout/stderr, detects the port, and s
 
 ---
 
+## 📊 Web Dashboard
+
+
+Launch with `bgrun --dashboard` and open `http://localhost:3001`. Processes are auto-grouped by working directory.
+
+**Expose with Caddy** for remote access:
+
+```
+bgrun.yourdomain.com {
+    reverse_proxy localhost:3001
+}
+```
+
+Features:
+- Real-time process status via SSE (no polling)
+- Start, stop, restart, and delete processes from the UI
+- Live stdout/stderr log viewer with search
+- Memory, PID, port, and runtime at a glance
+- Responsive mobile layout
+- Collapsible directory groups
+
+---
+
 ## Table of Contents
 
 - [Core Commands](#core-commands)
@@ -697,6 +720,6 @@ MIT
 
 <div align="center">
 
-Built by [Mements](https://github.com/Mements) with ⚡ Bun
+Built with ⚡ Bun
 
 </div>

package/dashboard/app/globals.css

@@ -652,9 +652,14 @@ table {
 }
 
 .group-header td {
-    padding: 0.875rem 1.25rem 0.5rem 1.25rem !important;
-    background: transparent !important;
-    border: none !important;
+    padding: 0.625rem 1.25rem 0.375rem 1.25rem !important;
+    background: rgba(255, 255, 255, 0.015) !important;
+    border-bottom: 1px solid var(--border-subtle) !important;
+    border-top: 1px solid var(--border-glass) !important;
+}
+
+.group-header:first-child td {
+    border-top: none !important;
 }
 
 .group-header:hover td {
@@ -664,20 +669,18 @@ table {
 .group-label {
     display: flex;
     align-items: center;
-    gap: 0.5rem;
-    font-size: 0.75rem;
-    font-weight: 700;
-    text-transform: uppercase;
-    letter-spacing: 0.05em;
-    color: var(--text-muted);
+    gap: 0.375rem;
+    font-size: 0.6875rem;
+    font-weight: 600;
+    color: var(--text-dim);
 }
 
 .group-chevron {
-    width: 14px;
-    height: 14px;
+    width: 12px;
+    height: 12px;
     stroke: var(--text-dim);
     fill: none;
-    stroke-width: 2;
+    stroke-width: 2.5;
     transition: transform var(--transition-fast);
     transform: rotate(90deg);
     flex-shrink: 0;
@@ -687,28 +690,21 @@ table {
     transform: rotate(0deg);
 }
 
-.group-icon {
-    font-size: 0.875rem;
-}
-
 .group-name {
-    color: var(--text-secondary);
-    font-size: 0.7rem;
+    color: var(--text-muted);
+    font-size: 0.6875rem;
     font-family: var(--font-mono);
-    letter-spacing: 0.02em;
+    letter-spacing: 0.01em;
     font-weight: 500;
-    text-transform: none;
 }
 
 .group-counts {
     display: flex;
     align-items: center;
-    gap: 0.375rem;
-    margin-left: 0.25rem;
-    font-size: 0.65rem;
+    gap: 0.25rem;
+    margin-left: auto;
+    font-size: 0.625rem;
     font-weight: 500;
-    text-transform: none;
-    letter-spacing: normal;
 }
 
 .group-count-running {
@@ -716,11 +712,11 @@ table {
 }
 
 .group-count-running.has-running {
-    color: var(--success);
+    color: var(--success-soft);
 }
 
 .group-count-sep {
-    color: var(--text-dim);
+    color: var(--border-hover);
 }
 
 .group-count-total {
@@ -916,6 +912,7 @@ tr.animate-in:nth-child(10) {
     color: var(--text-muted);
     font-size: 0.8125rem;
     font-family: var(--font-mono);
+    white-space: nowrap;
 }
 
 /* ─── Action Buttons (SVG-based) ─── */

package/dashboard/app/page.client.tsx

@@ -13,15 +13,14 @@ import { render as melinaRender, createElement as h, setReconciler } from 'melin
 
 interface ProcessData {
     name: string;
-    command: string;
-    directory: string;
     pid: number;
     running: boolean;
-    port: number | null;
-    ports: number[];
-    memory: number; // bytes
-    group: string | null;
-    runtime: string;
+    port: string;
+    command: string;
+    memory: number;
+    runtime: number;
+    directory: string;
+    group?: string;
     timestamp: string;
     env: string;
     configPath: string;
@@ -124,6 +123,17 @@ function formatTimeAgo(date: Date): string {
     return `${days}d ago`;
 }
 
+// ─── Helpers ───
+
+function shortenPath(dir: string): string {
+    if (!dir) return '';
+    const normalized = dir.replace(/\\/g, '/');
+    const parts = normalized.split('/');
+    // Show last 2 segments  (e.g. "Code/bgr" instead of "c:/Code/bgr")
+    if (parts.length > 2) return parts.slice(-2).join('/');
+    return normalized;
+}
+
 // ─── JSX Components ───
 
 function ProcessRow({ p, animate }: { p: ProcessData; animate?: boolean }) {
@@ -179,13 +189,14 @@ function ProcessRow({ p, animate }: { p: ProcessData; animate?: boolean }) {
 }
 
 function GroupHeader({ name, running, total, collapsed }: { name: string; running: number; total: number; collapsed: boolean }) {
+    // Show short folder name as label, full path as title
+    const shortName = shortenPath(name);
     return (
         <tr className={`group-header ${collapsed ? 'collapsed' : ''}`} data-group-name={name}>
             <td colSpan={8}>
-                <div className="group-label">
+                <div className="group-label" title={name}>
                     <svg className="group-chevron" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2"><path d="M9 18l6-6-6-6" /></svg>
-                    <span className="group-icon">📂</span>
-                    <span className="group-name">{name}</span>
+                    <span className="group-name">{shortName}</span>
                     <span className="group-counts">
                         <span className={`group-count-running ${running > 0 ? 'has-running' : ''}`}>{running} running</span>
                         <span className="group-count-sep">·</span>
@@ -338,6 +349,7 @@ export default function mount(): () => void {
     let drawerProcess: string | null = null;
     let drawerTab: 'stdout' | 'stderr' = 'stdout';
     let activeSection = 'logs'; // Which accordion section is open: 'info' | 'config' | 'logs'
+    let mutationUntil = 0; // Timestamp: ignore SSE updates until this time (after mutations)
     let configSubtab = 'toml'; // 'toml' | 'env'
     let logAutoScroll = localStorage.getItem('bgr_autoscroll') === 'true'; // OFF by default
     let logSearch = '';
@@ -425,7 +437,7 @@ export default function mount(): () => void {
 
         const animate = isFirstLoad;
 
-        // Always group by working directory
+        // Group by working directory
         const groups: Record<string, ProcessData[]> = {};
         processes.forEach(p => {
             const key = p.directory || 'Unknown';
@@ -436,24 +448,18 @@ export default function mount(): () => void {
         const nodes: Node[] = [];
         const sortedGroupKeys = Object.keys(groups).sort();
 
-        // If only one group, don't show group header
-        if (sortedGroupKeys.length === 1) {
-            groups[sortedGroupKeys[0]].forEach(p => {
-                nodes.push(<ProcessRow p={p} animate={animate} /> as unknown as Node);
-            });
-        } else {
-            sortedGroupKeys.forEach(groupDir => {
-                const procs = groups[groupDir];
-                const running = procs.filter(p => p.running).length;
-                const collapsed = collapsedGroups.has(groupDir);
-                nodes.push(<GroupHeader name={groupDir} running={running} total={procs.length} collapsed={collapsed} /> as unknown as Node);
-                if (!collapsed) {
-                    procs.forEach(p => {
-                        nodes.push(<ProcessRow p={p} animate={animate} /> as unknown as Node);
-                    });
-                }
-            });
-        }
+        // Always show group headers for every directory
+        sortedGroupKeys.forEach(groupDir => {
+            const procs = groups[groupDir];
+            const running = procs.filter(p => p.running).length;
+            const collapsed = collapsedGroups.has(groupDir);
+            nodes.push(<GroupHeader name={groupDir} running={running} total={procs.length} collapsed={collapsed} /> as unknown as Node);
+            if (!collapsed) {
+                procs.forEach(p => {
+                    nodes.push(<ProcessRow p={p} animate={animate} /> as unknown as Node);
+                });
+            }
+        });
 
         tbody.replaceChildren(...nodes);
 
@@ -539,6 +545,7 @@ export default function mount(): () => void {
                     showToast(`Failed to stop "${name}"`, 'error');
                 }
                 await loadProcessesFresh();
+                mutationUntil = Date.now() + 3000;
                 break;
             }
 
@@ -562,6 +569,7 @@ export default function mount(): () => void {
                     showToast(`Failed to restart "${name}"`, 'error');
                 }
                 await loadProcessesFresh();
+                mutationUntil = Date.now() + 3000;
                 break;
             }
 
@@ -583,6 +591,7 @@ export default function mount(): () => void {
                     showToast(`Failed to delete "${name}"`, 'error');
                 }
                 await loadProcessesFresh();
+                mutationUntil = Date.now() + 3000;
                 break;
             }
 
@@ -1173,6 +1182,8 @@ export default function mount(): () => void {
     function connectSSE() {
         eventSource = new EventSource('/api/events');
         eventSource.onmessage = (event) => {
+            // Skip SSE updates briefly after mutations to avoid flicker
+            if (Date.now() < mutationUntil) return;
             try {
                 allProcesses = JSON.parse(event.data);
                 // Throttle table re-renders to avoid lag on rapid SSE

package/dashboard/app/page.tsx

@@ -76,7 +76,7 @@ export default function DashboardPage() {
                             <th style={{ width: '70px' }}>Port</th>
                             <th style={{ width: '70px' }}>Memory</th>
                             <th>Command</th>
-                            <th style={{ width: '80px' }}>Runtime</th>
+                            <th style={{ width: '100px' }}>Runtime</th>
                             <th style={{ width: '150px' }}>Actions</th>
                         </tr>
                     </thead>

package/dist/index.js

@@ -1,16 +1,23 @@
 #!/usr/bin/env bun
 // @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// src/index.ts
-import { parseArgs } from "util";
-
 // src/platform.ts
 import * as fs from "fs";
 import * as os from "os";
 var {$ } = globalThis.Bun;
 import { createMeasure } from "measure-fn";
-var plat = createMeasure("platform");
 function isWindows() {
   return process.platform === "win32";
 }
@@ -312,8 +319,150 @@ async function getProcessPorts(pid) {
     return [];
   }
 }
+var plat;
+var init_platform = __esm(() => {
+  plat = createMeasure("platform");
+});
+
+// src/db.ts
+var exports_db = {};
+__export(exports_db, {
+  updateProcessPid: () => updateProcessPid,
+  retryDatabaseOperation: () => retryDatabaseOperation,
+  removeProcessByName: () => removeProcessByName,
+  removeProcess: () => removeProcess,
+  removeAllProcesses: () => removeAllProcesses,
+  insertProcess: () => insertProcess,
+  getProcess: () => getProcess,
+  getDbInfo: () => getDbInfo,
+  getAllProcesses: () => getAllProcesses,
+  dbPath: () => dbPath,
+  db: () => db,
+  bgrHome: () => bgrHome,
+  ProcessSchema: () => ProcessSchema
+});
+import { Database, z } from "sqlite-zod-orm";
+import { join } from "path";
+var {sleep } = globalThis.Bun;
+import { existsSync as existsSync3, copyFileSync as copyFileSync2 } from "fs";
+function getProcess(name) {
+  return db.process.select().where({ name }).orderBy("timestamp", "desc").limit(1).get() || null;
+}
+function getAllProcesses() {
+  return db.process.select().all();
+}
+function insertProcess(data) {
+  return db.process.insert({
+    ...data,
+    timestamp: new Date().toISOString()
+  });
+}
+function removeProcess(pid) {
+  const matches = db.process.select().where({ pid }).all();
+  for (const p of matches) {
+    db.process.delete(p.id);
+  }
+}
+function removeProcessByName(name) {
+  const matches = db.process.select().where({ name }).all();
+  for (const p of matches) {
+    db.process.delete(p.id);
+  }
+}
+function updateProcessPid(name, newPid) {
+  const proc = db.process.select().where({ name }).limit(1).get();
+  if (proc) {
+    db.process.update(proc.id, { pid: newPid });
+  }
+}
+function removeAllProcesses() {
+  const all = db.process.select().all();
+  for (const p of all) {
+    db.process.delete(p.id);
+  }
+}
+function getDbInfo() {
+  return {
+    dbPath,
+    bgrHome,
+    dbFilename,
+    exists: existsSync3(dbPath)
+  };
+}
+async function retryDatabaseOperation(operation, maxRetries = 5, delay = 100) {
+  for (let attempt = 1;attempt <= maxRetries; attempt++) {
+    try {
+      return operation();
+    } catch (err) {
+      if (err?.code === "SQLITE_BUSY" && attempt < maxRetries) {
+        await sleep(delay * attempt);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error("Max retries reached for database operation");
+}
+var ProcessSchema, homePath, bgrDir, dbFilename, dbPath, bgrHome, legacyDbPath, db;
+var init_db = __esm(() => {
+  init_platform();
+  ProcessSchema = z.object({
+    pid: z.number(),
+    workdir: z.string(),
+    command: z.string(),
+    name: z.string(),
+    env: z.string(),
+    configPath: z.string().default(""),
+    stdout_path: z.string(),
+    stderr_path: z.string(),
+    timestamp: z.string().default(() => new Date().toISOString())
+  });
+  homePath = getHomeDir();
+  bgrDir = join(homePath, ".bgr");
+  ensureDir(bgrDir);
+  dbFilename = process.env.BGRUN_DB ?? "bgrun.sqlite";
+  dbPath = join(bgrDir, dbFilename);
+  bgrHome = bgrDir;
+  legacyDbPath = join(bgrDir, "bgr_v2.sqlite");
+  if (!existsSync3(dbPath) && existsSync3(legacyDbPath)) {
+    try {
+      copyFileSync2(legacyDbPath, dbPath);
+      console.log(`[bgrun] Migrated database: ${legacyDbPath} \u2192 ${dbPath}`);
+    } catch (e) {}
+  }
+  db = new Database(dbPath, {
+    process: ProcessSchema
+  }, {
+    indexes: {
+      process: ["name", "timestamp", "pid"]
+    }
+  });
+});
+
+// src/server.ts
+var exports_server = {};
+__export(exports_server, {
+  startServer: () => startServer
+});
+import path2 from "path";
+async function startServer() {
+  const { start } = await import("melina");
+  const appDir = path2.join(import.meta.dir, "../dashboard/app");
+  const explicitPort = process.env.BUN_PORT ? parseInt(process.env.BUN_PORT, 10) : undefined;
+  await start({
+    appDir,
+    defaultTitle: "bgrun Dashboard - Process Manager",
+    globalCss: path2.join(appDir, "globals.css"),
+    ...explicitPort !== undefined && { port: explicitPort }
+  });
+}
+var init_server = () => {};
+
+// src/index.ts
+import { parseArgs } from "util";
 
 // src/utils.ts
+init_platform();
 import * as fs2 from "fs";
 import chalk from "chalk";
 function parseEnvString(envString) {
@@ -391,94 +540,9 @@ function tailFile(path, prefix, colorFn, lines) {
   };
 }
 
-// src/db.ts
-import { Database, z } from "sqlite-zod-orm";
-import { join } from "path";
-var {sleep } = globalThis.Bun;
-import { existsSync as existsSync3, copyFileSync as copyFileSync2 } from "fs";
-var ProcessSchema = z.object({
-  pid: z.number(),
-  workdir: z.string(),
-  command: z.string(),
-  name: z.string(),
-  env: z.string(),
-  configPath: z.string().default(""),
-  stdout_path: z.string(),
-  stderr_path: z.string(),
-  timestamp: z.string().default(() => new Date().toISOString())
-});
-var homePath = getHomeDir();
-var bgrDir = join(homePath, ".bgr");
-ensureDir(bgrDir);
-var dbFilename = process.env.BGRUN_DB ?? "bgrun.sqlite";
-var dbPath = join(bgrDir, dbFilename);
-var bgrHome = bgrDir;
-var legacyDbPath = join(bgrDir, "bgr_v2.sqlite");
-if (!existsSync3(dbPath) && existsSync3(legacyDbPath)) {
-  try {
-    copyFileSync2(legacyDbPath, dbPath);
-    console.log(`[bgrun] Migrated database: ${legacyDbPath} \u2192 ${dbPath}`);
-  } catch (e) {}
-}
-var db = new Database(dbPath, {
-  process: ProcessSchema
-}, {
-  indexes: {
-    process: ["name", "timestamp", "pid"]
-  }
-});
-function getProcess(name) {
-  return db.process.select().where({ name }).orderBy("timestamp", "desc").limit(1).get() || null;
-}
-function getAllProcesses() {
-  return db.process.select().all();
-}
-function insertProcess(data) {
-  return db.process.insert({
-    ...data,
-    timestamp: new Date().toISOString()
-  });
-}
-function removeProcess(pid) {
-  const matches = db.process.select().where({ pid }).all();
-  for (const p of matches) {
-    db.process.delete(p.id);
-  }
-}
-function removeProcessByName(name) {
-  const matches = db.process.select().where({ name }).all();
-  for (const p of matches) {
-    db.process.delete(p.id);
-  }
-}
-function removeAllProcesses() {
-  const all = db.process.select().all();
-  for (const p of all) {
-    db.process.delete(p.id);
-  }
-}
-function getDbInfo() {
-  return {
-    dbPath,
-    bgrHome,
-    dbFilename,
-    exists: existsSync3(dbPath)
-  };
-}
-async function retryDatabaseOperation(operation, maxRetries = 5, delay = 100) {
-  for (let attempt = 1;attempt <= maxRetries; attempt++) {
-    try {
-      return operation();
-    } catch (err) {
-      if (err?.code === "SQLITE_BUSY" && attempt < maxRetries) {
-        await sleep(delay * attempt);
-        continue;
-      }
-      throw err;
-    }
-  }
-  throw new Error("Max retries reached for database operation");
-}
+// src/commands/run.ts
+init_db();
+init_platform();
 
 // src/logger.ts
 import boxen from "boxen";
@@ -831,6 +895,8 @@ function renderProcessTable(processes, options) {
 }
 
 // src/commands/list.ts
+init_db();
+init_platform();
 function formatMemory(bytes) {
   if (bytes === 0)
     return "-";
@@ -904,6 +970,8 @@ async function showAll(opts) {
 }
 
 // src/commands/cleanup.ts
+init_db();
+init_platform();
 import * as fs3 from "fs";
 async function handleDelete(name) {
   const process2 = getProcess(name);
@@ -1020,6 +1088,8 @@ async function handleDeleteAll() {
 }
 
 // src/commands/watch.ts
+init_db();
+init_platform();
 import * as fs4 from "fs";
 import path from "path";
 import chalk5 from "chalk";
@@ -1208,6 +1278,8 @@ SIGINT received...`));
 }
 
 // src/commands/logs.ts
+init_db();
+init_platform();
 import chalk6 from "chalk";
 import * as fs5 from "fs";
 async function showLogs(name, logType = "both", lines) {
@@ -1251,6 +1323,8 @@ async function showLogs(name, logType = "both", lines) {
 }
 
 // src/commands/details.ts
+init_db();
+init_platform();
 import chalk7 from "chalk";
 async function showDetails(name) {
   const proc = getProcess(name);
@@ -1285,21 +1359,9 @@ ${Object.entries(envVars).map(([key, value]) => `${chalk7.cyan.bold(key)} = ${ch
   announce(details, `Process Details: ${name}`);
 }
 
-// src/server.ts
-import { start } from "melina";
-import path2 from "path";
-async function startServer() {
-  const appDir = path2.join(import.meta.dir, "../dashboard/app");
-  const explicitPort = process.env.BUN_PORT ? parseInt(process.env.BUN_PORT, 10) : undefined;
-  await start({
-    appDir,
-    defaultTitle: "bgrun Dashboard - Process Manager",
-    globalCss: path2.join(appDir, "globals.css"),
-    ...explicitPort !== undefined && { port: explicitPort }
-  });
-}
-
 // src/index.ts
+init_platform();
+init_db();
 import dedent from "dedent";
 import chalk8 from "chalk";
 import { join as join3 } from "path";
@@ -1323,7 +1385,9 @@ async function showHelp() {
       bgrun [name]             Show details for a process
       bgrun --dashboard        Launch web dashboard (managed by bgrun)
       bgrun --restart [name]   Restart a process
+      bgrun --restart-all      Restart ALL registered processes
       bgrun --stop [name]      Stop a process (keep in registry)
+      bgrun --stop-all         Stop ALL running processes
       bgrun --delete [name]    Delete a process
       bgrun --clean            Remove all stopped processes
       bgrun --nuke             Delete ALL processes
@@ -1369,7 +1433,9 @@ async function run2() {
       delete: { type: "boolean" },
       nuke: { type: "boolean" },
       restart: { type: "boolean" },
+      "restart-all": { type: "boolean" },
       stop: { type: "boolean" },
+      "stop-all": { type: "boolean" },
       clean: { type: "boolean" },
       json: { type: "boolean" },
       logs: { type: "boolean" },
@@ -1391,7 +1457,8 @@ async function run2() {
     allowPositionals: true
   });
   if (values["_serve"]) {
-    await startServer();
+    const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
+    await startServer2();
     return;
   }
   if (values.dashboard) {
@@ -1401,14 +1468,20 @@ async function run2() {
     const requestedPort = values.port;
     const existing = getProcess(dashboardName);
     if (existing && await isProcessRunning(existing.pid)) {
-      const existingPorts = await getProcessPorts(existing.pid);
+      let existingPorts = await getProcessPorts(existing.pid);
+      if (existingPorts.length === 0) {
+        const childPid = await findChildPid(existing.pid);
+        if (childPid !== existing.pid) {
+          existingPorts = await getProcessPorts(childPid);
+        }
+      }
       const portStr = existingPorts.length > 0 ? `:${existingPorts[0]}` : "(detecting...)";
       announce(`Dashboard is already running (PID ${existing.pid})
 
 ` + `  \uD83C\uDF10  ${chalk8.cyan(`http://localhost${portStr}`)}
 
-` + `  Use ${chalk8.yellow(`bgrun --stop ${dashboardName}`)} to stop it
-` + `  Use ${chalk8.yellow(`bgrun --dashboard --force`)} to restart`, "BGR Dashboard");
+  Use ${chalk8.yellow(`bgrun --stop ${dashboardName}`)} to stop it
+  Use ${chalk8.yellow(`bgrun --dashboard --force`)} to restart`, "BGR Dashboard");
       return;
     }
     if (existing) {
@@ -1514,6 +1587,61 @@ async function run2() {
     await handleClean();
     return;
   }
+  if (values["restart-all"]) {
+    const { getAllProcesses: getAllProcesses2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+    const all = getAllProcesses2();
+    if (all.length === 0) {
+      error("No processes registered.");
+      return;
+    }
+    console.log(chalk8.bold(`
+  Restarting ${all.length} processes...
+`));
+    for (const proc of all) {
+      try {
+        console.log(chalk8.yellow(`  \u21BB Restarting ${proc.name}...`));
+        await handleRun({
+          action: "run",
+          name: proc.name,
+          force: true,
+          remoteName: ""
+        });
+      } catch (err) {
+        console.error(chalk8.red(`  \u2717 Failed to restart ${proc.name}: ${err.message}`));
+      }
+    }
+    console.log(chalk8.green(`
+  \u2713 All processes restarted.
+`));
+    return;
+  }
+  if (values["stop-all"]) {
+    const { getAllProcesses: getAllProcesses2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+    const all = getAllProcesses2();
+    if (all.length === 0) {
+      error("No processes registered.");
+      return;
+    }
+    console.log(chalk8.bold(`
+  Stopping ${all.length} processes...
+`));
+    for (const proc of all) {
+      try {
+        if (await isProcessRunning(proc.pid)) {
+          console.log(chalk8.yellow(`  \u25A0 Stopping ${proc.name} (PID ${proc.pid})...`));
+          await handleStop(proc.name);
+        } else {
+          console.log(chalk8.gray(`  \u25CB ${proc.name} already stopped`));
+        }
+      } catch (err) {
+        console.error(chalk8.red(`  \u2717 Failed to stop ${proc.name}: ${err.message}`));
+      }
+    }
+    console.log(chalk8.green(`
+  \u2713 All processes stopped.
+`));
+    return;
+  }
   const name = values.name || positionals[0];
   if (values.delete) {
     if (name) {

package/package.json

@@ -1,59 +1,60 @@
-{
-  "name": "bgrun",
-  "version": "3.7.0",
-  "description": "bgrun — A lightweight process manager for Bun",
-  "type": "module",
-  "main": "./src/api.ts",
-  "exports": {
-    ".": "./src/api.ts"
-  },
-  "bin": {
-    "bgrun": "./dist/index.js"
-  },
-  "scripts": {
-    "build": "bun run ./src/build.ts",
-    "test": "bun test",
-    "prepublishOnly": "bun run build"
-  },
-  "files": [
-    "dist",
-    "src",
-    "dashboard/app",
-    "README.md",
-    "examples/bgr-startup.sh"
-  ],
-  "keywords": [
-    "process-manager",
-    "bun",
-    "monitoring",
-    "devops",
-    "deployment",
-    "background",
-    "daemon"
-  ],
-  "author": "7flash",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Mements/bgr.git"
-  },
-  "devDependencies": {
-    "bun-types": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "^5.0.0"
-  },
-  "dependencies": {
-    "boxen": "^8.0.1",
-    "chalk": "^5.4.1",
-    "dedent": "^1.5.3",
-    "measure-fn": "^3.2.1",
-    "melina": "^2.2.1",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4",
-    "sqlite-zod-orm": "^3.8.0"
-  },
-  "engines": {
-    "bun": ">=1.0.0"
-  }
-}
+{
+  "name": "bgrun",
+  "version": "3.7.1",
+  "description": "bgrun — A lightweight process manager for Bun",
+  "type": "module",
+  "main": "./src/api.ts",
+  "exports": {
+    ".": "./src/api.ts"
+  },
+  "bin": {
+    "bgrun": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "bun run ./src/build.ts",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "files": [
+    "dist",
+    "src",
+    "dashboard/app",
+    "README.md",
+    "image.png",
+    "examples/bgr-startup.sh"
+  ],
+  "keywords": [
+    "process-manager",
+    "bun",
+    "monitoring",
+    "devops",
+    "deployment",
+    "background",
+    "daemon"
+  ],
+  "author": "7flash",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/7flash/bgrun.git"
+  },
+  "devDependencies": {
+    "bun-types": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
+    "dedent": "^1.5.3",
+    "measure-fn": "^3.2.1",
+    "melina": "^2.2.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "sqlite-zod-orm": "^3.8.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}

package/src/api.ts

@@ -48,3 +48,16 @@ export { handleRun } from './commands/run'
 
 // --- Utilities ---
 export { getVersion, calculateRuntime, parseEnvString, validateDirectory } from './utils'
+
+// --- Default Export (namespace style) ---
+import { getAllProcesses, getProcess, insertProcess, removeProcess, removeProcessByName, removeAllProcesses, retryDatabaseOperation, getDbInfo, dbPath, bgrHome } from './db'
+import { isProcessRunning, terminateProcess, readFileTail, getProcessPorts, findChildPid, findPidByPort, getShellCommand, killProcessOnPort, waitForPortFree, ensureDir, getHomeDir, isWindows, getProcessBatchMemory, getProcessMemory } from './platform'
+import { handleRun } from './commands/run'
+import { getVersion, calculateRuntime, parseEnvString, validateDirectory } from './utils'
+
+export default {
+    getAllProcesses, getProcess, insertProcess, removeProcess, removeProcessByName, removeAllProcesses, retryDatabaseOperation, getDbInfo, dbPath, bgrHome,
+    isProcessRunning, terminateProcess, readFileTail, getProcessPorts, findChildPid, findPidByPort, getShellCommand, killProcessOnPort, waitForPortFree, ensureDir, getHomeDir, isWindows, getProcessBatchMemory, getProcessMemory,
+    handleRun,
+    getVersion, calculateRuntime, parseEnvString, validateDirectory,
+}

package/src/index.ts

@@ -10,7 +10,8 @@ import { showLogs } from "./commands/logs";
 import { showDetails } from "./commands/details";
 import type { CommandOptions } from "./types";
 import { error, announce } from "./logger";
-import { startServer } from "./server";
+// startServer is dynamically imported only when --_serve is used
+// to avoid loading melina (which has side-effects) on every bgrun command
 import { getHomeDir, getShellCommand, findChildPid, isProcessRunning, terminateProcess, getProcessPorts, killProcessOnPort, waitForPortFree } from "./platform";
 import { insertProcess, removeProcessByName, getProcess, retryDatabaseOperation, getDbInfo } from "./db";
 import dedent from "dedent";
@@ -38,7 +39,9 @@ async function showHelp() {
       bgrun [name]             Show details for a process
       bgrun --dashboard        Launch web dashboard (managed by bgrun)
       bgrun --restart [name]   Restart a process
+      bgrun --restart-all      Restart ALL registered processes
       bgrun --stop [name]      Stop a process (keep in registry)
+      bgrun --stop-all         Stop ALL running processes
       bgrun --delete [name]    Delete a process
       bgrun --clean            Remove all stopped processes
       bgrun --nuke             Delete ALL processes
@@ -86,7 +89,9 @@ async function run() {
       delete: { type: 'boolean' },
       nuke: { type: 'boolean' },
       restart: { type: 'boolean' },
+      "restart-all": { type: 'boolean' },
       stop: { type: 'boolean' },
+      "stop-all": { type: 'boolean' },
       clean: { type: 'boolean' },
       json: { type: 'boolean' },
       logs: { type: 'boolean' },
@@ -112,6 +117,7 @@ async function run() {
   // Port is NOT passed explicitly — Melina auto-detects from BUN_PORT env
   // or defaults to 3000 with fallback to next available port.
   if (values['_serve']) {
+    const { startServer } = await import("./server");
     await startServer();
     return;
   }
@@ -128,7 +134,15 @@ async function run() {
     // Check if dashboard is already running
     const existing = getProcess(dashboardName);
     if (existing && await isProcessRunning(existing.pid)) {
-      const existingPorts = await getProcessPorts(existing.pid);
+      // The stored PID may be the shell wrapper (cmd.exe), not the actual bun process
+      // Try the stored PID first, then traverse the process tree to find the real one
+      let existingPorts = await getProcessPorts(existing.pid);
+      if (existingPorts.length === 0) {
+        const childPid = await findChildPid(existing.pid);
+        if (childPid !== existing.pid) {
+          existingPorts = await getProcessPorts(childPid);
+        }
+      }
       const portStr = existingPorts.length > 0 ? `:${existingPorts[0]}` : '(detecting...)';
       announce(
         `Dashboard is already running (PID ${existing.pid})\n\n` +
@@ -270,6 +284,57 @@ async function run() {
     return;
   }
 
+  // Restart all registered processes
+  if (values['restart-all']) {
+    const { getAllProcesses } = await import('./db');
+    const all = getAllProcesses();
+    if (all.length === 0) {
+      error('No processes registered.');
+      return;
+    }
+    console.log(chalk.bold(`\n  Restarting ${all.length} processes...\n`));
+    for (const proc of all) {
+      try {
+        console.log(chalk.yellow(`  ↻ Restarting ${proc.name}...`));
+        await handleRun({
+          action: 'run',
+          name: proc.name,
+          force: true,
+          remoteName: '',
+        });
+      } catch (err: any) {
+        console.error(chalk.red(`  ✗ Failed to restart ${proc.name}: ${err.message}`));
+      }
+    }
+    console.log(chalk.green(`\n  ✓ All processes restarted.\n`));
+    return;
+  }
+
+  // Stop all running processes
+  if (values['stop-all']) {
+    const { getAllProcesses } = await import('./db');
+    const all = getAllProcesses();
+    if (all.length === 0) {
+      error('No processes registered.');
+      return;
+    }
+    console.log(chalk.bold(`\n  Stopping ${all.length} processes...\n`));
+    for (const proc of all) {
+      try {
+        if (await isProcessRunning(proc.pid)) {
+          console.log(chalk.yellow(`  ■ Stopping ${proc.name} (PID ${proc.pid})...`));
+          await handleStop(proc.name);
+        } else {
+          console.log(chalk.gray(`  ○ ${proc.name} already stopped`));
+        }
+      } catch (err: any) {
+        console.error(chalk.red(`  ✗ Failed to stop ${proc.name}: ${err.message}`));
+      }
+    }
+    console.log(chalk.green(`\n  ✓ All processes stopped.\n`));
+    return;
+  }
+
   const name = (values.name as string) || positionals[0];
 
   // Delete

package/src/server.ts

@@ -8,10 +8,11 @@
  *   - If BUN_PORT env var is set → uses that (explicit, will fail if busy)
  *   - Otherwise → defaults to 3000, falls back to next available if busy
  */
-import { start } from 'melina';
 import path from 'path';
 
 export async function startServer() {
+    // Dynamic import to avoid melina's side-effect console.log at bundle load time
+    const { start } = await import('melina');
     const appDir = path.join(import.meta.dir, '../dashboard/app');
 
     // Only pass port when BUN_PORT is explicitly set.

package/src/types.ts

@@ -1,10 +1,10 @@
 export interface CommandOptions {
-    remoteName: string;
+    remoteName?: string;
     command?: string;
     directory?: string;
     env?: Record<string, string>;
     configPath?: string;
-    action: string;
+    action?: string;
     name?: string;
     force?: boolean;
     fetch?: boolean;