bgrun 3.10.1 → 3.11.0

package/src/log-rotation.ts

@@ -0,0 +1,93 @@
+/**
+ * Log rotation for bgrun process output files.
+ * 
+ * Ensures log files don't grow unbounded by:
+ * 1. Truncating on rotation (restart) — keeping last N lines
+ * 2. Size-based rotation — when file exceeds maxBytes, trim to last N lines
+ * 3. Periodic rotation check — runs on an interval in the dashboard
+ */
+
+import { existsSync, statSync, readFileSync, writeFileSync } from 'fs'
+
+const DEFAULT_MAX_BYTES = 10 * 1024 * 1024  // 10 MB
+const DEFAULT_KEEP_LINES = 5000             // Keep last 5000 lines on rotation
+const DEFAULT_CHECK_INTERVAL_MS = 60_000    // Check every 60s
+
+/** Rotate a single log file if it exceeds maxBytes */
+export function rotateLogFile(
+    filePath: string,
+    maxBytes: number = DEFAULT_MAX_BYTES,
+    keepLines: number = DEFAULT_KEEP_LINES,
+): boolean {
+    try {
+        if (!existsSync(filePath)) return false
+
+        const stat = statSync(filePath)
+        if (stat.size <= maxBytes) return false
+
+        // Read file, keep last N lines
+        const content = readFileSync(filePath, 'utf-8')
+        const lines = content.split('\n')
+
+        if (lines.length <= keepLines) return false
+
+        const truncated = lines.slice(-keepLines)
+        const header = `--- [bgrun] Log rotated at ${new Date().toISOString()} (was ${lines.length} lines, ${formatBytes(stat.size)}) ---\n`
+        writeFileSync(filePath, header + truncated.join('\n'))
+
+        return true
+    } catch {
+        return false
+    }
+}
+
+/** Rotate all log files for all processes */
+export function rotateAllLogs(
+    getProcesses: () => Array<{ name: string; stdout_path: string; stderr_path: string }>,
+    maxBytes: number = DEFAULT_MAX_BYTES,
+    keepLines: number = DEFAULT_KEEP_LINES,
+): { rotated: string[]; checked: number } {
+    const processes = getProcesses()
+    const rotated: string[] = []
+    let checked = 0
+
+    for (const proc of processes) {
+        if (proc.stdout_path) {
+            checked++
+            if (rotateLogFile(proc.stdout_path, maxBytes, keepLines)) {
+                rotated.push(`${proc.name}/stdout`)
+            }
+        }
+        if (proc.stderr_path) {
+            checked++
+            if (rotateLogFile(proc.stderr_path, maxBytes, keepLines)) {
+                rotated.push(`${proc.name}/stderr`)
+            }
+        }
+    }
+
+    return { rotated, checked }
+}
+
+/** Start periodic log rotation */
+export function startLogRotation(
+    getProcesses: () => Array<{ name: string; stdout_path: string; stderr_path: string }>,
+    intervalMs: number = DEFAULT_CHECK_INTERVAL_MS,
+    maxBytes: number = DEFAULT_MAX_BYTES,
+    keepLines: number = DEFAULT_KEEP_LINES,
+): ReturnType<typeof setInterval> {
+    console.log(`[logs] Log rotation active: max ${formatBytes(maxBytes)}/file, keep ${keepLines} lines, check every ${intervalMs / 1000}s`)
+
+    return setInterval(() => {
+        const { rotated } = rotateAllLogs(getProcesses, maxBytes, keepLines)
+        if (rotated.length > 0) {
+            console.log(`[logs] Rotated ${rotated.length} log(s): ${rotated.join(', ')}`)
+        }
+    }, intervalMs)
+}
+
+function formatBytes(bytes: number): string {
+    if (bytes >= 1_000_000) return `${(bytes / 1_000_000).toFixed(1)}MB`
+    if (bytes >= 1_000) return `${(bytes / 1_000).toFixed(0)}KB`
+    return `${bytes}B`
+}

package/src/logger.ts

@@ -3,7 +3,7 @@ import chalk from "chalk";
 
 export function announce(message: string, title?: string) {
     console.log(
-        boxen(chalk.white(message), {
+        boxen(message, {
             padding: 1,
             margin: 1,
             borderColor: 'green',
@@ -14,9 +14,10 @@ export function announce(message: string, title?: string) {
     );
 }
 
-export function error(message: string) {
+export function error(message: string | Error) {
+    const text = message instanceof Error ? (message.stack || message.message) : String(message);
     console.error(
-        boxen(chalk.red(message), {
+        boxen(chalk.red(text), {
             padding: 1,
             margin: 1,
             borderColor: 'red',

package/src/platform.ts

@@ -31,7 +31,7 @@ export async function isProcessRunning(pid: number, command?: string): Promise<b
   // PID 0 means intentionally stopped — never alive
   if (pid <= 0) return false;
 
-  return plat.measure(`PID ${pid} alive?`, async () => {
+  return (await 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'))) {
@@ -48,7 +48,7 @@ export async function isProcessRunning(pid: number, command?: string): Promise<b
     } catch {
       return false;
     }
-  });
+  })) ?? false;
 }
 
 /**
@@ -224,8 +224,10 @@ export async function killProcessOnPort(port: number): Promise<void> {
         if (alive) {
           await $`taskkill /F /T /PID ${pid}`.nothrow().quiet();
           console.log(`Killed process ${pid} using port ${port}`);
+        } else {
+          // Zombie socket — PID no longer exists but socket lingers in kernel
+          console.warn(`⚠ Port ${port} held by zombie PID ${pid} (process dead, socket stuck in kernel). Will clear on reboot or TCP timeout.`);
         }
-        // else: zombie socket — PID no longer exists but socket lingers in kernel
       }
     } else {
       // On Unix, use lsof
@@ -456,7 +458,7 @@ export async function findPidByPort(port: number, maxWaitMs = 8000): Promise<num
 }
 
 export async function readFileTail(filePath: string, lines?: number): Promise<string> {
-  return plat.measure(`Read tail ${lines ?? 'all'}L`, async () => {
+  return (await plat.measure(`Read tail ${lines ?? 'all'}L`, async () => {
     try {
       const content = await Bun.file(filePath).text();
 
@@ -470,7 +472,7 @@ export async function readFileTail(filePath: string, lines?: number): Promise<st
     } catch (error) {
       throw new Error(`Error reading file: ${error}`);
     }
-  });
+  })) ?? '';
 }
 
 /**
@@ -484,56 +486,70 @@ export function copyFile(src: string, dest: string): void {
  * Get memory usage of a process in bytes
  */
 export async function getProcessMemory(pid: number): Promise<number> {
-  const map = await getProcessBatchMemory([pid]);
-  return map.get(pid) || 0;
+  const map = await getProcessBatchResources([pid]);
+  return map.get(pid)?.memory || 0;
 }
 
 /**
- * Get memory usage for a batch of PIDs in bytes.
- * Returns a Map of PID -> Memory (bytes).
+ * Get memory and CPU usage for a batch of PIDs.
+ * Returns a Map of PID -> { memory: bytes, cpu: number }.
+ * On Windows, CPU is cumulative time in seconds.
+ * On Unix, CPU is instantaneous percentage.
  * 
  * Optimization: Fetches ALL processes in one go and filters in-memory
  * to avoid spawning N subprocesses.
  */
-export async function getProcessBatchMemory(pids: number[]): Promise<Map<number, number>> {
+export async function getProcessBatchResources(pids: number[]): Promise<Map<number, { memory: number, cpu: number }>> {
   if (pids.length === 0) return new Map();
 
-  return await plat.measure(`Batch memory (${pids.length} PIDs)`, async () => {
-    const memoryMap = new Map<number, number>();
+  return await plat.measure(`Batch resources (${pids.length} PIDs)`, async () => {
+    const resourceMap = new Map<number, { memory: number, cpu: number }>();
     const pidSet = new Set(pids);
 
     try {
       if (isWindows()) {
-        const result = await $`powershell -Command "Get-Process | Select-Object Id, WorkingSet"`.nothrow().quiet().text();
+        const result = await $`powershell -Command "Get-Process | Select-Object Id, CPU, 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;
 
+          // Replace multiple spaces with a single space to parse correctly
           const parts = trimmed.split(/\s+/);
-          if (parts.length >= 2) {
-            const val1 = parseInt(parts[0]);
-            const val2 = parseInt(parts[parts.length - 1]);
+          if (parts.length >= 3) {
+            const pid = parseInt(parts[0]);
+            // CPU can sometimes be blank if process is just starting, handle that
+            let cpuStr = parts[1];
+            let memStr = parts[2];
+            if (parts.length === 2) {
+              // If CPU is missing, powershell might omit it and give just ID and WorkingSet
+              cpuStr = "0";
+              memStr = parts[1];
+            }
+
+            const cpu = parseFloat(cpuStr) || 0;
+            const memory = parseInt(memStr) || 0;
 
-            if (!isNaN(val1) && !isNaN(val2)) {
-              if (pidSet.has(val1)) memoryMap.set(val1, val2);
+            if (!isNaN(pid) && !isNaN(memory)) {
+              if (pidSet.has(pid)) resourceMap.set(pid, { memory, cpu });
             }
           }
         }
       } else {
-        const result = await $`ps -eo pid,rss`.nothrow().quiet().text();
+        const result = await $`ps -eo pid,pcpu,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 [pidStr, cpuStr, rssStr] = line.split(/\s+/);
           const pid = parseInt(pidStr);
-          const rss = parseInt(rssStr);
+          const cpu = parseFloat(cpuStr) || 0;
+          const rss = parseInt(rssStr) || 0;
 
           if (pidSet.has(pid)) {
-            memoryMap.set(pid, rss * 1024);
+            resourceMap.set(pid, { memory: rss * 1024, cpu });
           }
         }
       }
@@ -541,7 +557,7 @@ export async function getProcessBatchMemory(pids: number[]): Promise<Map<number,
       // silently fail
     }
 
-    return memoryMap;
+    return resourceMap;
   }) ?? new Map();
 }
 

package/src/server.ts

@@ -17,9 +17,17 @@ import path from 'path';
 import { getAllProcesses, getProcess } from './db';
 import { isProcessRunning } from './platform';
 import { handleRun } from './commands/run';
+import { parseEnvString } from './utils';
 
 const GUARD_INTERVAL_MS = 30_000; // Check every 30 seconds
-const GUARD_SKIP_NAMES = new Set(['bgr-dashboard']); // Don't try to restart ourselves
+const GUARD_SKIP_NAMES = new Set(['bgr-dashboard', 'bgr-guard']); // Don't try to restart ourselves or external guard
+
+// In-memory guard restart counter and timestamps (persists across module re-evaluations)
+const _g = globalThis as any;
+if (!_g.__bgrGuardRestartCounts) _g.__bgrGuardRestartCounts = new Map<string, number>();
+if (!_g.__bgrGuardNextRestartTime) _g.__bgrGuardNextRestartTime = new Map<string, number>();
+export const guardRestartCounts: Map<string, number> = _g.__bgrGuardRestartCounts;
+const guardNextRestartTime: Map<string, number> = _g.__bgrGuardNextRestartTime;
 
 export async function startServer() {
     // Dynamic import to avoid melina's side-effect console.log at bundle load time
@@ -38,21 +46,25 @@ export async function startServer() {
 
     // Start the built-in process guard
     startGuard();
+
+    // Start log rotation (prevents unbounded log file growth)
+    const { startLogRotation } = await import('./log-rotation');
+    startLogRotation(() => getAllProcesses());
 }
 
 /**
  * Built-in Process Guard
  * 
  * Runs as a background loop inside the dashboard process.
- * Every GUARD_INTERVAL_MS, it checks all registered bgrun processes.
- * If any process is dead (PID not running), it auto-restarts it using
- * handleRun with force=true (same as `bgrun --restart <name>`).
+ * Every GUARD_INTERVAL_MS, checks processes with BGR_KEEP_ALIVE=true
+ * in their env and auto-restarts any that died.
  * 
- * Why here and not as a separate process?
- * - No external dependency — the dashboard IS the guardian
- * - If the dashboard is running, all processes are monitored
- * - If the dashboard dies, `bgrun --dashboard` will restart everything
- * - Zero configuration — just works
+ * Only guarded processes (opted-in via dashboard toggle or env var) are
+ * monitored. Other processes are left alone even if they crash.
+ * 
+ * Toggle guard per-process:
+ *   - Dashboard UI: click the shield icon on any process row
+ *   - CLI: set BGR_KEEP_ALIVE=true in the process env/config
  */
 function startGuard() {
     console.log(`[guard] ✓ Built-in process guard started (checking every ${GUARD_INTERVAL_MS / 1000}s)`);
@@ -66,9 +78,17 @@ function startGuard() {
                 // Skip the dashboard itself
                 if (GUARD_SKIP_NAMES.has(proc.name)) continue;
 
+                // Only guard processes with BGR_KEEP_ALIVE=true
+                const env = proc.env ? parseEnvString(proc.env) : {};
+                if (env.BGR_KEEP_ALIVE !== 'true') continue;
+
                 const alive = await isProcessRunning(proc.pid, proc.command);
                 if (!alive) {
-                    console.log(`[guard] ⚠ Process "${proc.name}" (PID ${proc.pid}) is dead, restarting...`);
+                    const now = Date.now();
+                    const nextRestart = guardNextRestartTime.get(proc.name) || 0;
+                    if (now < nextRestart) continue; // Still in backoff period
+
+                    console.log(`[guard] ⚠ Guarded process "${proc.name}" (PID ${proc.pid}) is dead, restarting...`);
                     try {
                         await handleRun({
                             action: 'run',
@@ -76,10 +96,34 @@ function startGuard() {
                             force: true,
                             remoteName: '',
                         });
-                        console.log(`[guard] ✓ Restarted "${proc.name}"`);
+
+                        // Track restart count
+                        const prevCount = guardRestartCounts.get(proc.name) || 0;
+                        const newCount = prevCount + 1;
+                        guardRestartCounts.set(proc.name, newCount);
+
+                        // Exponential backoff if it crashes repeatedly (more than 5 times)
+                        if (newCount > 5) {
+                            const backoffSeconds = Math.min(30 * Math.pow(2, newCount - 6), 300); // 30s, 60s, 120s, up to 5 mins
+                            guardNextRestartTime.set(proc.name, Date.now() + (backoffSeconds * 1000));
+                            console.log(`[guard] ✓ Restarted "${proc.name}" (restart #${newCount}). Crash loop detected: next check delayed by ${backoffSeconds}s.`);
+                        } else {
+                            console.log(`[guard] ✓ Restarted "${proc.name}" (restart #${newCount})`);
+                        }
                     } catch (err: any) {
                         console.error(`[guard] ✗ Failed to restart "${proc.name}": ${err.message}`);
                     }
+                } else {
+                    // Reset counter if process has been stable (alive at least once during check)
+                    const prevCount = guardRestartCounts.get(proc.name) || 0;
+                    if (prevCount > 0) {
+                        const nextRestart = guardNextRestartTime.get(proc.name) || 0;
+                        if (Date.now() > nextRestart + 60_000) {
+                            // If it lived over 60s past its backoff threshold, consider it stable
+                            guardRestartCounts.delete(proc.name);
+                            guardNextRestartTime.delete(proc.name);
+                        }
+                    }
                 }
             }
         } catch (err: any) {