bgrun 3.4.0 → 3.7.0

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

@@ -17,6 +17,13 @@ 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`
@@ -244,7 +251,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}

package/src/platform.ts

@@ -5,7 +5,11 @@
 
 import * as fs from "fs";
 import * as os from "os";
+import { join } from "path";
 import { $ } from "bun";
+import { measure, createMeasure } from "measure-fn";
+
+const plat = createMeasure('platform');
 
 /** Detect if running on Windows - use function to prevent bundler tree-shaking */
 export function isWindows(): boolean {
@@ -24,24 +28,24 @@ export function getHomeDir(): string {
  * For Docker containers, checks container status instead of PID
  */
 export async function isProcessRunning(pid: number, command?: string): Promise<boolean> {
-  try {
-    // Docker container detection
-    if (command && (command.includes('docker run') || command.includes('docker-compose up') || command.includes('docker compose up'))) {
-      return await isDockerContainerRunning(command);
-    }
+  return plat.measure(`PID ${pid} alive?`, async () => {
+    try {
+      // Docker container detection
+      if (command && (command.includes('docker run') || command.includes('docker-compose up') || command.includes('docker compose up'))) {
+        return await isDockerContainerRunning(command);
+      }
 
-    if (isWindows()) {
-      // On Windows, use tasklist to check for PID
-      const result = await $`tasklist /FI "PID eq ${pid}" /NH`.nothrow().text();
-      return result.includes(`${pid}`);
-    } else {
-      // On Unix, use ps -p
-      const result = await $`ps -p ${pid}`.nothrow().text();
-      return result.includes(`${pid}`);
+      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;
-  }
+  });
 }
 
 /**
@@ -104,46 +108,48 @@ async function getChildPids(pid: number): Promise<number[]> {
  * Terminate a process and its children
  */
 export async function terminateProcess(pid: number, force: boolean = false): Promise<void> {
-  // First, kill children
-  const children = await getChildPids(pid);
+  await plat.measure(`Terminate PID ${pid}`, async (m) => {
+    // First, kill children
+    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();
+    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 {
+        // Ignore errors for already-dead processes
       }
-    } catch {
-      // Ignore errors for already-dead processes
     }
-  }
 
-  // Wait a bit for graceful shutdown
-  await Bun.sleep(500);
+    // Wait a bit for graceful shutdown
+    await Bun.sleep(500);
 
-  // Then kill the parent if still running
-  if (await isProcessRunning(pid)) {
-    try {
-      if (isWindows()) {
-        if (force) {
-          await $`taskkill /F /PID ${pid}`.nothrow().quiet();
+    // Then kill the parent if still running
+    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 {
+        // Ignore errors
       }
-    } catch {
-      // Ignore errors
     }
-  }
+  });
 }
 
 /**
@@ -297,6 +303,108 @@ export async function findChildPid(parentPid: number): Promise<number> {
   return currentPid;
 }
 
+/**
+ * Reconcile stale PIDs: when a stored PID is dead, search for a live process
+ * matching the same command line and update the DB with the correct PID.
+ * 
+ * This handles the case where cmd.exe wrapper PIDs die after spawning the
+ * actual bun.exe child process, or after a system reboot where PIDs change.
+ * 
+ * Returns a map of process name → reconciled PID for all matched processes.
+ */
+export async function reconcileProcessPids(
+  processes: Array<{ name: string; pid: number; command: string; workdir: string }>,
+  deadPids: Set<number>,
+): Promise<Map<string, number>> {
+  return await plat.measure('Reconcile PIDs', async () => {
+    const result = new Map<string, number>();
+    const needsReconciliation = processes.filter(p => deadPids.has(p.pid));
+    if (needsReconciliation.length === 0) return result;
+
+    try {
+      // Get all running processes with their command lines
+      let runningProcs: Array<{ pid: number; cmdLine: string }> = [];
+
+      if (isWindows()) {
+        // Write a temp PS1 script to avoid quoting issues with $() in Bun's shell
+        const tmpScript = join(os.tmpdir(), 'bgr-reconcile.ps1');
+        const psCode = `Get-CimInstance Win32_Process | Where-Object { $_.Name -eq 'bun.exe' } | ForEach-Object { Write-Output "$($_.ProcessId)|$($_.CommandLine)" }`;
+        await Bun.write(tmpScript, psCode);
+
+        const ps = Bun.spawnSync(['powershell', '-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', tmpScript]);
+        const output = ps.stdout.toString();
+
+        for (const line of output.split('\n')) {
+          const sepIdx = line.indexOf('|');
+          if (sepIdx === -1) continue;
+          const pid = parseInt(line.substring(0, sepIdx).trim());
+          const cmdLine = line.substring(sepIdx + 1).trim();
+          if (!isNaN(pid) && pid > 0 && cmdLine) {
+            runningProcs.push({ pid, cmdLine });
+          }
+        }
+      } else {
+        const psOutput = await $`ps -eo pid,args --no-headers`.nothrow().quiet().text();
+        for (const line of psOutput.trim().split('\n')) {
+          const match = line.trim().match(/^(\d+)\s+(.+)/);
+          if (match) {
+            runningProcs.push({ pid: parseInt(match[1]), cmdLine: match[2] });
+          }
+        }
+      }
+
+      // For each dead process, try to find a matching live process
+      // Uses multi-criteria scoring to avoid false matches when multiple
+      // processes share similar commands (e.g. "bun run server.ts")
+      for (const proc of needsReconciliation) {
+        const cmdParts = proc.command.split(/\s+/);
+        // Extract meaningful parts: full command and workdir path segments
+        const workdirParts = proc.workdir.replace(/\\/g, '/').split('/').filter(Boolean);
+        const workdirLast = workdirParts[workdirParts.length - 1]?.toLowerCase() || '';
+
+        let bestMatch: { pid: number; score: number } | null = null;
+        let ambiguous = false;
+
+        for (const running of runningProcs) {
+          const cmdLower = running.cmdLine.toLowerCase();
+          let score = 0;
+
+          // Score 1: command parts match (e.g. "run", "server.ts")
+          for (const part of cmdParts) {
+            if (part.length > 2 && cmdLower.includes(part.toLowerCase())) score++;
+          }
+
+          // Score 2: workdir folder name appears in command line path
+          // This distinguishes "bun run server.ts" in different directories
+          if (workdirLast && cmdLower.includes(workdirLast)) score += 3;
+
+          // Score 3: full workdir path match (strongest signal)
+          if (cmdLower.includes(proc.workdir.toLowerCase().replace(/\\/g, '/'))) score += 5;
+          if (cmdLower.includes(proc.workdir.toLowerCase())) score += 5;
+
+          if (score < 4) continue; // Require workdir evidence — generic cmd matches alone aren't enough
+
+          if (!bestMatch || score > bestMatch.score) {
+            ambiguous = false;
+            bestMatch = { pid: running.pid, score };
+          } else if (score === bestMatch.score) {
+            ambiguous = true; // Multiple equally good matches — skip
+          }
+        }
+
+        if (bestMatch && !ambiguous) {
+          result.set(proc.name, bestMatch.pid);
+          runningProcs = runningProcs.filter(p => p.pid !== bestMatch!.pid);
+        }
+      }
+    } catch {
+      // Reconciliation is best-effort — return partial results
+    }
+
+    return result;
+  }) ?? new Map();
+}
+
 /**
  * Wait for a port to become active and return the PID listening on it.
  * More reliable than findChildPid since it waits for the actual server
@@ -341,19 +449,21 @@ export async function findPidByPort(port: number, maxWaitMs = 8000): Promise<num
 }
 
 export async function readFileTail(filePath: string, lines?: number): Promise<string> {
-  try {
-    const content = await Bun.file(filePath).text();
+  return plat.measure(`Read tail ${lines ?? 'all'}L`, async () => {
+    try {
+      const content = await Bun.file(filePath).text();
 
-    if (!lines) {
-      return content;
-    }
+      if (!lines) {
+        return content;
+      }
 
-    const allLines = content.split(/\r?\n/);
-    const tailLines = allLines.slice(-lines);
-    return tailLines.join('\n');
-  } catch (error) {
-    throw new Error(`Error reading file: ${error}`);
-  }
+      const allLines = content.split(/\r?\n/);
+      const tailLines = allLines.slice(-lines);
+      return tailLines.join('\n');
+    } catch (error) {
+      throw new Error(`Error reading file: ${error}`);
+    }
+  });
 }
 
 /**
@@ -379,57 +489,53 @@ export async function getProcessMemory(pid: number): Promise<number> {
  * to avoid spawning N subprocesses.
  */
 export async function getProcessBatchMemory(pids: number[]): Promise<Map<number, number>> {
-  const memoryMap = new Map<number, number>();
-  if (pids.length === 0) return memoryMap;
+  if (pids.length === 0) return new Map();
 
-  // Create a quick lookup set
-  const pidSet = new Set(pids);
+  return await plat.measure(`Batch memory (${pids.length} PIDs)`, async () => {
+    const memoryMap = new Map<number, number>();
+    const pidSet = new Set(pids);
 
-  try {
-    if (isWindows()) {
-      // Get-Process | Select-Object Id, WorkingSet
-      const result = await $`powershell -Command "Get-Process | Select-Object Id, WorkingSet"`.nothrow().quiet().text();
-      const lines = result.trim().split('\n');
+    try {
+      if (isWindows()) {
+        const result = await $`powershell -Command "Get-Process | Select-Object Id, WorkingSet"`.nothrow().quiet().text();
+        const lines = result.trim().split('\n');
 
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('Id') || trimmed.startsWith('--')) continue;
+        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]);
+          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);
+            if (!isNaN(val1) && !isNaN(val2)) {
+              if (pidSet.has(val1)) memoryMap.set(val1, val2);
+            }
           }
         }
-      }
-    } else {
-      // Unix: ps -o pid,rss
-      // PID   RSS
-      // 123   456
-      const result = await $`ps -eo pid,rss`.nothrow().quiet().text();
-      const lines = result.trim().split('\n');
-
-      // Skip header
-      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); // KB
-
-        if (pidSet.has(pid)) {
-          memoryMap.set(pid, rss * 1024); // Convert KB to Bytes
+      } else {
+        const result = await $`ps -eo pid,rss`.nothrow().quiet().text();
+        const lines = result.trim().split('\n');
+
+        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) {
+      // silently fail
     }
-  } catch (e) {
-    // console.error("Error fetching batch memory:", e);
-  }
 
-  return memoryMap;
+    return memoryMap;
+  }) ?? new Map();
 }
 
 /**