bgrun 3.4.0 → 3.7.1

package/package.json

@@ -1,56 +1,60 @@
-{
-  "name": "bgrun",
-  "version": "3.4.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",
-    "melina": "^1.3.2",
-    "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/commands/list.ts

@@ -5,6 +5,7 @@ import { getAllProcesses } from "../db";
 import { announce } from "../logger";
 import { isProcessRunning, calculateRuntime, parseEnvString } from "../utils";
 import { getProcessPorts, getProcessBatchMemory } from "../platform";
+import { measure } from "measure-fn";
 
 function formatMemory(bytes: number): string {
     if (bytes === 0) return '-';

package/src/commands/run.ts

@@ -1,4 +1,4 @@
-import { CommandOptions } from "../types";
+import type { CommandOptions } from "../types";
 import { getProcess, removeProcessByName, retryDatabaseOperation, insertProcess } from "../db";
 import { isProcessRunning, terminateProcess, getHomeDir, getShellCommand, killProcessOnPort, findChildPid, getProcessPorts, waitForPortFree } from "../platform";
 import { error, announce } from "../logger";
@@ -7,8 +7,10 @@ import { parseConfigFile } from "../config";
 import { $ } from "bun";
 import { sleep } from "bun";
 import { join } from "path";
+import { createMeasure } from "measure-fn";
 
 const homePath = getHomeDir();
+const run = createMeasure('run');
 
 export async function handleRun(options: CommandOptions) {
     const { command, directory, env, name, configPath, force, fetch, stdout, stderr } = options;
@@ -24,18 +26,20 @@ export async function handleRun(options: CommandOptions) {
             if (!require('fs').existsSync(require('path').join(finalDirectory, '.git'))) {
                 error(`Cannot --fetch: '${finalDirectory}' is not a Git repository.`);
             }
-            try {
-                await $`git fetch origin`;
-                const localHash = (await $`git rev-parse HEAD`.text()).trim();
-                const remoteHash = (await $`git rev-parse origin/$(git rev-parse --abbrev-ref HEAD)`.text()).trim();
-
-                if (localHash !== remoteHash) {
-                    await $`git pull origin $(git rev-parse --abbrev-ref HEAD)`;
-                    announce("📥 Pulled latest changes", "Git Update");
+            await run.measure(`Git fetch "${name}"`, async () => {
+                try {
+                    await $`git fetch origin`;
+                    const localHash = (await $`git rev-parse HEAD`.text()).trim();
+                    const remoteHash = (await $`git rev-parse origin/$(git rev-parse --abbrev-ref HEAD)`.text()).trim();
+
+                    if (localHash !== remoteHash) {
+                        await $`git pull origin $(git rev-parse --abbrev-ref HEAD)`;
+                        announce("📥 Pulled latest changes", "Git Update");
+                    }
+                } catch (err) {
+                    error(`Failed to pull latest changes: ${err}`);
                 }
-            } catch (err) {
-                error(`Failed to pull latest changes: ${err}`);
-            }
+            });
         }
 
         const isRunning = await isProcessRunning(existingProcess.pid);
@@ -50,23 +54,26 @@ export async function handleRun(options: CommandOptions) {
         }
 
         if (isRunning) {
-            await terminateProcess(existingProcess.pid);
-            announce(`🔥 Terminated existing process '${name}'`, "Process Terminated");
+            await run.measure(`Terminate "${name}" (PID ${existingProcess.pid})`, async () => {
+                await terminateProcess(existingProcess.pid);
+                announce(`🔥 Terminated existing process '${name}'`, "Process Terminated");
+            });
         }
 
         // Kill anything still on the ports the old process was using
-        for (const port of detectedPorts) {
-            await killProcessOnPort(port);
-        }
-
-        // Wait for all detected ports to free up
-        for (const port of detectedPorts) {
-            const freed = await waitForPortFree(port, 5000);
-            if (!freed) {
-                // Retry kill and wait once more
-                await killProcessOnPort(port);
-                await waitForPortFree(port, 3000);
-            }
+        if (detectedPorts.length > 0) {
+            await run.measure(`Port cleanup [${detectedPorts.join(', ')}]`, async () => {
+                for (const port of detectedPorts) {
+                    await killProcessOnPort(port);
+                }
+                for (const port of detectedPorts) {
+                    const freed = await waitForPortFree(port, 5000);
+                    if (!freed) {
+                        await killProcessOnPort(port);
+                        await waitForPortFree(port, 3000);
+                    }
+                }
+            });
         }
 
         await retryDatabaseOperation(() =>
@@ -97,12 +104,17 @@ export async function handleRun(options: CommandOptions) {
         const fullConfigPath = join(finalDirectory, finalConfigPath);
 
         if (await Bun.file(fullConfigPath).exists()) {
-            try {
-                const newConfigEnv = await parseConfigFile(fullConfigPath);
-                finalEnv = { ...finalEnv, ...newConfigEnv };
+            const configEnv = await run.measure(`Parse config "${finalConfigPath}"`, async () => {
+                try {
+                    return await parseConfigFile(fullConfigPath);
+                } catch (err: any) {
+                    console.warn(`Warning: Failed to parse config file ${finalConfigPath}: ${err.message}`);
+                    return null;
+                }
+            });
+            if (configEnv) {
+                finalEnv = { ...finalEnv, ...configEnv };
                 console.log(`Loaded config from ${finalConfigPath}`);
-            } catch (err: any) {
-                console.warn(`Warning: Failed to parse config file ${finalConfigPath}: ${err.message}`);
             }
         } else {
             console.log(`Config file '${finalConfigPath}' not found, continuing without it.`);
@@ -114,20 +126,23 @@ export async function handleRun(options: CommandOptions) {
     const stderrPath = stderr || existingProcess?.stderr_path || join(homePath, ".bgr", `${name}-err.txt`);
     Bun.write(stderrPath, '');
 
-    const newProcess = Bun.spawn(getShellCommand(finalCommand!), {
-        env: { ...Bun.env, ...finalEnv },
-        cwd: finalDirectory,
-        stdout: Bun.file(stdoutPath),
-        stderr: Bun.file(stderrPath),
-    });
-
-    newProcess.unref();
-    // Give shell a moment to spawn child, then find PID before shell exits
-    await sleep(100);
-    // Find the actual child PID (shell wrapper exits immediately after spawning)
-    const actualPid = await findChildPid(newProcess.pid);
-    // Wait more for subprocess to initialize
-    await sleep(400);
+    const actualPid = await run.measure(`Spawn "${name}" → ${finalCommand}`, async () => {
+        const newProcess = Bun.spawn(getShellCommand(finalCommand!), {
+            env: { ...Bun.env, ...finalEnv },
+            cwd: finalDirectory,
+            stdout: Bun.file(stdoutPath),
+            stderr: Bun.file(stderrPath),
+        });
+
+        newProcess.unref();
+        // Give shell a moment to spawn child, then find PID before shell exits
+        await sleep(100);
+        // Find the actual child PID (shell wrapper exits immediately after spawning)
+        const pid = await findChildPid(newProcess.pid);
+        // Wait more for subprocess to initialize
+        await sleep(400);
+        return pid;
+    }) ?? 0;
 
     await retryDatabaseOperation(() =>
         insertProcess({
@@ -147,5 +162,3 @@ export async function handleRun(options: CommandOptions) {
         "Process Started"
     );
 }
-
-

package/src/db.ts

@@ -2,6 +2,7 @@ import { Database, z } from "sqlite-zod-orm";
 import { getHomeDir, ensureDir } from "./platform";
 import { join } from "path";
 import { sleep } from "bun";
+import { existsSync, copyFileSync } from "fs";
 
 // =============================================================================
 // SCHEMA (inline — single table, no need for a separate file)
@@ -27,11 +28,24 @@ export type Process = z.infer<typeof ProcessSchema> & { id: number };
 
 const homePath = getHomeDir();
 const bgrDir = join(homePath, ".bgr");
-const dbName = process.env.DB_NAME ?? "bgr";
-export const dbPath = join(bgrDir, `${dbName}_v2.sqlite`);
-export const bgrHome = bgrDir;
 ensureDir(bgrDir);
 
+// DB filename: configurable via BGRUN_DB env, default "bgrun.sqlite"
+const dbFilename = process.env.BGRUN_DB ?? "bgrun.sqlite";
+export const dbPath = join(bgrDir, dbFilename);
+export const bgrHome = bgrDir;
+
+// Auto-migration: if new DB doesn't exist but old one does, copy it over
+const legacyDbPath = join(bgrDir, "bgr_v2.sqlite");
+if (!existsSync(dbPath) && existsSync(legacyDbPath)) {
+    try {
+        copyFileSync(legacyDbPath, dbPath);
+        console.log(`[bgrun] Migrated database: ${legacyDbPath} → ${dbPath}`);
+    } catch (e) {
+        // Migration failed — start fresh
+    }
+}
+
 export const db = new Database(dbPath, {
     process: ProcessSchema,
 }, {
@@ -90,6 +104,14 @@ export function removeProcessByName(name: string) {
     }
 }
 
+/** Update the stored PID for a process (used by PID reconciliation) */
+export function updateProcessPid(name: string, newPid: number) {
+    const proc = db.process.select().where({ name }).limit(1).get();
+    if (proc) {
+        db.process.update(proc.id, { pid: newPid });
+    }
+}
+
 export function removeAllProcesses() {
     const all = db.process.select().all();
     for (const p of all) {
@@ -105,8 +127,8 @@ export function getDbInfo() {
     return {
         dbPath,
         bgrHome,
-        dbName,
-        exists: require('fs').existsSync(dbPath),
+        dbFilename,
+        exists: existsSync(dbPath),
     };
 }
 

package/src/index.ts

@@ -10,13 +10,21 @@ 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";
 import chalk from "chalk";
 import { join } from "path";
 import { sleep } from "bun";
+import { configure } from "measure-fn";
+
+if (!Bun.argv.includes("--_serve")) {
+  if (!Bun.env.MEASURE_SILENT) {
+    configure({ silent: true });
+  }
+}
 
 async function showHelp() {
   const usage = dedent`
@@ -31,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
@@ -79,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' },
@@ -105,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;
   }
@@ -121,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` +
@@ -244,7 +265,7 @@ async function run() {
       Version:   ${chalk.cyan(version)}
       BGR Home:  ${chalk.yellow(info.bgrHome)}
       DB Path:   ${chalk.yellow(info.dbPath)}
-      DB Name:   ${info.dbName}
+      DB File:   ${info.dbFilename}
       DB Exists: ${info.exists ? chalk.green('✓') : chalk.red('✗')}
       Platform:  ${process.platform}
       Bun:       ${Bun.version}
@@ -263,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