bgrun 3.3.3 → 3.7.0

package/dist/index.js

@@ -9,6 +9,8 @@ import { parseArgs } from "util";
 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";
 }
@@ -16,20 +18,22 @@ function getHomeDir() {
   return os.homedir();
 }
 async function isProcessRunning(pid, command) {
-  try {
-    if (command && (command.includes("docker run") || command.includes("docker-compose up") || command.includes("docker compose up"))) {
-      return await isDockerContainerRunning(command);
-    }
-    if (isWindows()) {
-      const result = await $`tasklist /FI "PID eq ${pid}" /NH`.nothrow().text();
-      return result.includes(`${pid}`);
-    } else {
-      const result = await $`ps -p ${pid}`.nothrow().text();
-      return result.includes(`${pid}`);
+  return plat.measure(`PID ${pid} alive?`, async () => {
+    try {
+      if (command && (command.includes("docker run") || command.includes("docker-compose up") || command.includes("docker compose up"))) {
+        return await isDockerContainerRunning(command);
+      }
+      if (isWindows()) {
+        const result = await $`tasklist /FI "PID eq ${pid}" /NH`.nothrow().text();
+        return result.includes(`${pid}`);
+      } else {
+        const result = await $`ps -p ${pid}`.nothrow().text();
+        return result.includes(`${pid}`);
+      }
+    } catch {
+      return false;
     }
-  } catch {
-    return false;
-  }
+  });
 }
 async function isDockerContainerRunning(command) {
   try {
@@ -53,7 +57,7 @@ async function isDockerContainerRunning(command) {
 async function getChildPids(pid) {
   try {
     if (isWindows()) {
-      const result = await $`wmic process where (ParentProcessId=${pid}) get ProcessId`.nothrow().text();
+      const result = await $`powershell -Command "Get-CimInstance Win32_Process -Filter 'ParentProcessId=${pid}' | Select-Object -ExpandProperty ProcessId"`.nothrow().text();
       return result.split(`
 `).map((line) => parseInt(line.trim())).filter((n) => !isNaN(n) && n > 0);
     } else {
@@ -66,36 +70,38 @@ async function getChildPids(pid) {
   }
 }
 async function terminateProcess(pid, force = false) {
-  const children = await getChildPids(pid);
-  for (const childPid of children) {
-    try {
-      if (isWindows()) {
-        if (force) {
-          await $`taskkill /F /PID ${childPid}`.nothrow().quiet();
+  await plat.measure(`Terminate PID ${pid}`, async (m) => {
+    const children = await m("Get children", () => getChildPids(pid)) ?? [];
+    for (const childPid of children) {
+      try {
+        if (isWindows()) {
+          if (force) {
+            await $`taskkill /F /PID ${childPid}`.nothrow().quiet();
+          } else {
+            await $`taskkill /PID ${childPid}`.nothrow().quiet();
+          }
         } else {
-          await $`taskkill /PID ${childPid}`.nothrow().quiet();
+          const signal = force ? "KILL" : "TERM";
+          await $`kill -${signal} ${childPid}`.nothrow();
         }
-      } else {
-        const signal = force ? "KILL" : "TERM";
-        await $`kill -${signal} ${childPid}`.nothrow();
-      }
-    } catch {}
-  }
-  await Bun.sleep(500);
-  if (await isProcessRunning(pid)) {
-    try {
-      if (isWindows()) {
-        if (force) {
-          await $`taskkill /F /PID ${pid}`.nothrow().quiet();
+      } catch {}
+    }
+    await Bun.sleep(500);
+    if (await isProcessRunning(pid)) {
+      try {
+        if (isWindows()) {
+          if (force) {
+            await $`taskkill /F /PID ${pid}`.nothrow().quiet();
+          } else {
+            await $`taskkill /PID ${pid}`.nothrow().quiet();
+          }
         } else {
-          await $`taskkill /PID ${pid}`.nothrow().quiet();
+          const signal = force ? "KILL" : "TERM";
+          await $`kill -${signal} ${pid}`.nothrow();
         }
-      } else {
-        const signal = force ? "KILL" : "TERM";
-        await $`kill -${signal} ${pid}`.nothrow();
-      }
-    } catch {}
-  }
+      } catch {}
+    }
+  });
 }
 async function isPortFree(port) {
   try {
@@ -200,18 +206,65 @@ async function findChildPid(parentPid) {
   return currentPid;
 }
 async function readFileTail(filePath, lines) {
-  try {
-    const content = await Bun.file(filePath).text();
-    if (!lines) {
-      return content;
+  return plat.measure(`Read tail ${lines ?? "all"}L`, async () => {
+    try {
+      const content = await Bun.file(filePath).text();
+      if (!lines) {
+        return content;
+      }
+      const allLines = content.split(/\r?\n/);
+      const tailLines = allLines.slice(-lines);
+      return tailLines.join(`
+`);
+    } catch (error) {
+      throw new Error(`Error reading file: ${error}`);
     }
-    const allLines = content.split(/\r?\n/);
-    const tailLines = allLines.slice(-lines);
-    return tailLines.join(`
+  });
+}
+async function getProcessBatchMemory(pids) {
+  if (pids.length === 0)
+    return new Map;
+  return await plat.measure(`Batch memory (${pids.length} PIDs)`, async () => {
+    const memoryMap = new Map;
+    const pidSet = new Set(pids);
+    try {
+      if (isWindows()) {
+        const result = await $`powershell -Command "Get-Process | Select-Object Id, WorkingSet"`.nothrow().quiet().text();
+        const lines = result.trim().split(`
 `);
-  } catch (error) {
-    throw new Error(`Error reading file: ${error}`);
-  }
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("Id") || trimmed.startsWith("--"))
+            continue;
+          const parts = trimmed.split(/\s+/);
+          if (parts.length >= 2) {
+            const val1 = parseInt(parts[0]);
+            const val2 = parseInt(parts[parts.length - 1]);
+            if (!isNaN(val1) && !isNaN(val2)) {
+              if (pidSet.has(val1))
+                memoryMap.set(val1, val2);
+            }
+          }
+        }
+      } else {
+        const result = await $`ps -eo pid,rss`.nothrow().quiet().text();
+        const lines = result.trim().split(`
+`);
+        for (let i = 1;i < lines.length; i++) {
+          const line = lines[i].trim();
+          if (!line)
+            continue;
+          const [pidStr, rssStr] = line.split(/\s+/);
+          const pid = parseInt(pidStr);
+          const rss = parseInt(rssStr);
+          if (pidSet.has(pid)) {
+            memoryMap.set(pid, rss * 1024);
+          }
+        }
+      }
+    } catch (e) {}
+    return memoryMap;
+  }) ?? new Map;
 }
 async function getProcessPorts(pid) {
   try {
@@ -342,6 +395,7 @@ function tailFile(path, prefix, colorFn, lines) {
 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(),
@@ -354,9 +408,18 @@ var ProcessSchema = z.object({
   timestamp: z.string().default(() => new Date().toISOString())
 });
 var homePath = getHomeDir();
-var dbName = process.env.DB_NAME ?? "bgr";
-var dbPath = join(homePath, ".bgr", `${dbName}_v2.sqlite`);
-ensureDir(join(homePath, ".bgr"));
+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
 }, {
@@ -394,6 +457,14 @@ function removeAllProcesses() {
     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 {
@@ -469,7 +540,9 @@ async function parseConfigFile(configPath) {
 var {$: $2 } = globalThis.Bun;
 var {sleep: sleep2 } = globalThis.Bun;
 import { join as join2 } from "path";
+import { createMeasure as createMeasure2 } from "measure-fn";
 var homePath2 = getHomeDir();
+var run = createMeasure2("run");
 async function handleRun(options) {
   const { command, directory, env, name, configPath, force, fetch, stdout, stderr } = options;
   const existingProcess = name ? getProcess(name) : null;
@@ -481,17 +554,19 @@ async function handleRun(options) {
       if (!__require("fs").existsSync(__require("path").join(finalDirectory2, ".git"))) {
         error(`Cannot --fetch: '${finalDirectory2}' is not a Git repository.`);
       }
-      try {
-        await $2`git fetch origin`;
-        const localHash = (await $2`git rev-parse HEAD`.text()).trim();
-        const remoteHash = (await $2`git rev-parse origin/$(git rev-parse --abbrev-ref HEAD)`.text()).trim();
-        if (localHash !== remoteHash) {
-          await $2`git pull origin $(git rev-parse --abbrev-ref HEAD)`;
-          announce("\uD83D\uDCE5 Pulled latest changes", "Git Update");
+      await run.measure(`Git fetch "${name}"`, async () => {
+        try {
+          await $2`git fetch origin`;
+          const localHash = (await $2`git rev-parse HEAD`.text()).trim();
+          const remoteHash = (await $2`git rev-parse origin/$(git rev-parse --abbrev-ref HEAD)`.text()).trim();
+          if (localHash !== remoteHash) {
+            await $2`git pull origin $(git rev-parse --abbrev-ref HEAD)`;
+            announce("\uD83D\uDCE5 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);
     if (isRunning && !force) {
@@ -502,18 +577,24 @@ async function handleRun(options) {
       detectedPorts = await getProcessPorts(existingProcess.pid);
     }
     if (isRunning) {
-      await terminateProcess(existingProcess.pid);
-      announce(`\uD83D\uDD25 Terminated existing process '${name}'`, "Process Terminated");
-    }
-    for (const port of detectedPorts) {
-      await killProcessOnPort(port);
+      await run.measure(`Terminate "${name}" (PID ${existingProcess.pid})`, async () => {
+        await terminateProcess(existingProcess.pid);
+        announce(`\uD83D\uDD25 Terminated existing process '${name}'`, "Process Terminated");
+      });
     }
-    for (const port of detectedPorts) {
-      const freed = await waitForPortFree(port, 5000);
-      if (!freed) {
-        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(() => removeProcessByName(name));
   } else {
@@ -537,12 +618,17 @@ async function handleRun(options) {
   if (finalConfigPath) {
     const fullConfigPath = join2(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) {
+          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) {
-        console.warn(`Warning: Failed to parse config file ${finalConfigPath}: ${err.message}`);
       }
     } else {
       console.log(`Config file '${finalConfigPath}' not found, continuing without it.`);
@@ -552,16 +638,19 @@ async function handleRun(options) {
   Bun.write(stdoutPath, "");
   const stderrPath = stderr || existingProcess?.stderr_path || join2(homePath2, ".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();
-  await sleep2(100);
-  const actualPid = await findChildPid(newProcess.pid);
-  await sleep2(400);
+  const actualPid = await run.measure(`Spawn "${name}" \u2192 ${finalCommand}`, async () => {
+    const newProcess = Bun.spawn(getShellCommand(finalCommand), {
+      env: { ...Bun.env, ...finalEnv },
+      cwd: finalDirectory,
+      stdout: Bun.file(stdoutPath),
+      stderr: Bun.file(stderrPath)
+    });
+    newProcess.unref();
+    await sleep2(100);
+    const pid = await findChildPid(newProcess.pid);
+    await sleep2(400);
+    return pid;
+  }) ?? 0;
   await retryDatabaseOperation(() => insertProcess({
     pid: actualPid,
     workdir: finalDirectory,
@@ -732,6 +821,7 @@ function renderProcessTable(processes, options) {
     { key: "pid", header: "PID", formatter: (pid) => chalk3.yellow(pid) },
     { key: "name", header: "Name", formatter: (name) => chalk3.cyan.bold(name) },
     { key: "port", header: "Port", formatter: (port) => port === "-" ? chalk3.gray(port) : chalk3.hex("#FF6B6B")(port) },
+    { key: "memory", header: "Memory", formatter: (mem) => mem === "-" ? chalk3.gray(mem) : chalk3.hex("#4ECDC4")(mem) },
     { key: "command", header: "Command" },
     { key: "workdir", header: "Directory", formatter: (dir) => chalk3.gray(dir), truncator: truncatePath },
     { key: "status", header: "Status" },
@@ -741,6 +831,14 @@ function renderProcessTable(processes, options) {
 }
 
 // src/commands/list.ts
+function formatMemory(bytes) {
+  if (bytes === 0)
+    return "-";
+  const mb = bytes / (1024 * 1024);
+  if (mb >= 1024)
+    return `${(mb / 1024).toFixed(1)} GB`;
+  return `${Math.round(mb)} MB`;
+}
 async function showAll(opts) {
   const processes = getAllProcesses();
   const filtered = processes.filter((proc) => {
@@ -767,15 +865,19 @@ async function showAll(opts) {
     return;
   }
   const tableData = [];
+  const allPids = filtered.map((p) => p.pid);
+  const memoryMap = await getProcessBatchMemory(allPids);
   for (const proc of filtered) {
     const isRunning = await isProcessRunning(proc.pid, proc.command);
     const runtime = calculateRuntime(proc.timestamp);
+    const mem = isRunning ? memoryMap.get(proc.pid) || 0 : 0;
     const ports = isRunning ? await getProcessPorts(proc.pid) : [];
     tableData.push({
       id: proc.id,
       pid: proc.pid,
       name: proc.name,
       port: ports.length > 0 ? ports.map((p) => `:${p}`).join(",") : "-",
+      memory: formatMemory(mem),
       command: proc.command,
       workdir: proc.workdir,
       status: isRunning ? chalk4.green.bold("\u25CF Running") : chalk4.red.bold("\u25CB Stopped"),
@@ -1202,6 +1304,12 @@ import dedent from "dedent";
 import chalk8 from "chalk";
 import { join as join3 } from "path";
 var {sleep: sleep3 } = globalThis.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`
     ${chalk8.bold("bgrun \u2014 Bun Background Runner")}
@@ -1235,6 +1343,7 @@ async function showHelp() {
       --log-stderr           Show only stderr logs
       --lines <n>            Number of log lines to show (default: all)
       --version              Show version
+      --debug                Show debug info (DB path, BGR home, etc.)
       --dashboard            Launch web dashboard as bgrun-managed process
       --port <number>        Port for dashboard (default: 3000)
       --help                 Show this help message
@@ -1246,7 +1355,7 @@ async function showHelp() {
   `;
   console.log(usage);
 }
-async function run() {
+async function run2() {
   const { values, positionals } = parseArgs({
     args: Bun.argv.slice(2),
     options: {
@@ -1274,6 +1383,7 @@ async function run() {
       stdout: { type: "string" },
       stderr: { type: "string" },
       dashboard: { type: "boolean" },
+      debug: { type: "boolean" },
       _serve: { type: "boolean" },
       port: { type: "string" }
     },
@@ -1287,7 +1397,7 @@ async function run() {
   if (values.dashboard) {
     const dashboardName = "bgr-dashboard";
     const homePath3 = getHomeDir();
-    const bgrDir = join3(homePath3, ".bgr");
+    const bgrDir2 = join3(homePath3, ".bgr");
     const requestedPort = values.port;
     const existing = getProcess(dashboardName);
     if (existing && await isProcessRunning(existing.pid)) {
@@ -1316,8 +1426,8 @@ async function run() {
     const scriptPath = resolve(process.argv[1]);
     const spawnCommand = `bun run ${scriptPath} --_serve`;
     const command = `bgrun --_serve`;
-    const stdoutPath = join3(bgrDir, `${dashboardName}-out.txt`);
-    const stderrPath = join3(bgrDir, `${dashboardName}-err.txt`);
+    const stdoutPath = join3(bgrDir2, `${dashboardName}-out.txt`);
+    const stderrPath = join3(bgrDir2, `${dashboardName}-err.txt`);
     await Bun.write(stdoutPath, "");
     await Bun.write(stderrPath, "");
     const spawnEnv = { ...Bun.env };
@@ -1326,7 +1436,7 @@ async function run() {
     }
     const newProcess = Bun.spawn(getShellCommand(spawnCommand), {
       env: spawnEnv,
-      cwd: bgrDir,
+      cwd: bgrDir2,
       stdout: Bun.file(stdoutPath),
       stderr: Bun.file(stderrPath)
     });
@@ -1344,7 +1454,7 @@ async function run() {
     }
     await retryDatabaseOperation(() => insertProcess({
       pid: actualPid,
-      workdir: bgrDir,
+      workdir: bgrDir2,
       command,
       name: dashboardName,
       env: "",
@@ -1380,6 +1490,22 @@ async function run() {
     await showHelp();
     return;
   }
+  if (values.debug) {
+    const info = getDbInfo();
+    const version = await getVersion();
+    console.log(dedent`
+      ${chalk8.bold("bgrun debug info")}
+      ${chalk8.gray("\u2500".repeat(40))}
+      Version:   ${chalk8.cyan(version)}
+      BGR Home:  ${chalk8.yellow(info.bgrHome)}
+      DB Path:   ${chalk8.yellow(info.dbPath)}
+      DB File:   ${info.dbFilename}
+      DB Exists: ${info.exists ? chalk8.green("\u2713") : chalk8.red("\u2717")}
+      Platform:  ${process.platform}
+      Bun:       ${Bun.version}
+    `);
+    return;
+  }
   if (values.nuke) {
     await handleDeleteAll();
     return;
@@ -1472,7 +1598,7 @@ async function run() {
     });
   }
 }
-run().catch((err) => {
+run2().catch((err) => {
   console.error(chalk8.red(err));
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bgrun",
-  "version": "3.3.3",
+  "version": "3.7.0",
   "description": "bgrun — A lightweight process manager for Bun",
   "type": "module",
   "main": "./src/api.ts",
@@ -47,10 +47,13 @@
     "boxen": "^8.0.1",
     "chalk": "^5.4.1",
     "dedent": "^1.5.3",
-    "melina": "^1.3.2",
+    "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

@@ -23,10 +23,25 @@ export type { Process } from './db'
 export type { CommandOptions } from './types'
 
 // --- Database Operations ---
-export { db, getAllProcesses, getProcess, insertProcess, removeProcess, removeProcessByName, removeAllProcesses, retryDatabaseOperation } from './db'
+export { db, getAllProcesses, getProcess, insertProcess, removeProcess, removeProcessByName, removeAllProcesses, retryDatabaseOperation, getDbInfo, dbPath, bgrHome } from './db'
 
 // --- Process Operations ---
-export { isProcessRunning, terminateProcess, readFileTail, getProcessPorts, findChildPid, findPidByPort, getShellCommand, killProcessOnPort, waitForPortFree, ensureDir, getHomeDir, isWindows } from './platform'
+export {
+    isProcessRunning,
+    terminateProcess,
+    readFileTail,
+    getProcessPorts,
+    findChildPid,
+    findPidByPort,
+    getShellCommand,
+    killProcessOnPort,
+    waitForPortFree,
+    ensureDir,
+    getHomeDir,
+    isWindows,
+    getProcessBatchMemory,
+    getProcessMemory
+} from './platform'
 
 // --- High-Level Commands ---
 export { handleRun } from './commands/run'

package/src/commands/list.ts

@@ -4,7 +4,15 @@ import type { ProcessTableRow } from "../table";
 import { getAllProcesses } from "../db";
 import { announce } from "../logger";
 import { isProcessRunning, calculateRuntime, parseEnvString } from "../utils";
-import { getProcessPorts } from "../platform";
+import { getProcessPorts, getProcessBatchMemory } from "../platform";
+import { measure } from "measure-fn";
+
+function formatMemory(bytes: number): string {
+    if (bytes === 0) return '-';
+    const mb = bytes / (1024 * 1024);
+    if (mb >= 1024) return `${(mb / 1024).toFixed(1)} GB`;
+    return `${Math.round(mb)} MB`;
+}
 
 export async function showAll(opts?: { json?: boolean; filter?: string }) {
     const processes = getAllProcesses();
@@ -41,9 +49,14 @@ export async function showAll(opts?: { json?: boolean; filter?: string }) {
     // Table output
     const tableData: ProcessTableRow[] = [];
 
+    // Batch fetch memory for all PIDs
+    const allPids = filtered.map(p => p.pid);
+    const memoryMap = await getProcessBatchMemory(allPids);
+
     for (const proc of filtered) {
         const isRunning = await isProcessRunning(proc.pid, proc.command);
         const runtime = calculateRuntime(proc.timestamp);
+        const mem = isRunning ? (memoryMap.get(proc.pid) || 0) : 0;
 
         const ports = isRunning ? await getProcessPorts(proc.pid) : [];
         tableData.push({
@@ -51,6 +64,7 @@ export async function showAll(opts?: { json?: boolean; filter?: string }) {
             pid: proc.pid,
             name: proc.name,
             port: ports.length > 0 ? ports.map(p => `:${p}`).join(',') : '-',
+            memory: formatMemory(mem),
             command: proc.command,
             workdir: proc.workdir,
             status: isRunning