bgrun 3.12.12 → 3.12.13

package/src/server.ts

@@ -1,217 +0,0 @@
-/**
- * BGR Dashboard Server + Built-in Process Guard
- * 
- * Uses Melina.js to serve the dashboard app with file-based routing.
- * All API endpoints and page rendering are handled by the dashboard/app/ directory.
- * 
- * v3.0: Built-in guard loop — the dashboard now monitors ALL registered
- * processes and auto-restarts any that die. This eliminates the need for
- * external guard scripts. The dashboard itself survives because bgrun
- * registers it as a managed process on launch.
- * 
- * Port selection is handled entirely by Melina:
- *   - 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 path from 'path';
-import { getAllProcesses, getProcess, addHistoryEntry } 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', '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>();
-if (!_g.__bgrGuardEvents) _g.__bgrGuardEvents = [] as { time: number; name: string; action: string; success: boolean }[];
-export const guardRestartCounts: Map<string, number> = _g.__bgrGuardRestartCounts;
-const guardNextRestartTime: Map<string, number> = _g.__bgrGuardNextRestartTime;
-export const guardEvents: { time: number; name: string; action: string; success: boolean }[] = _g.__bgrGuardEvents;
-
-/** Try to free a port from zombie processes (dead PIDs holding sockets) */
-async function cleanupPort(port: number): Promise<number> {
-    if (process.platform !== 'win32') return port;
-    try {
-        const proc = Bun.spawn(['powershell', '-NoProfile', '-Command',
-            `Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`
-        ], { stdout: 'pipe', stderr: 'pipe' });
-        const text = await new Response(proc.stdout).text();
-        const pid = parseInt(text.trim(), 10);
-        if (!pid || pid === process.pid) return port;
-
-        // Check if the owning process is actually dead
-        const checkProc = Bun.spawn(['powershell', '-NoProfile', '-Command',
-            `Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id`
-        ], { stdout: 'pipe', stderr: 'pipe' });
-        const checkText = await new Response(checkProc.stdout).text();
-        if (checkText.trim()) {
-            // Process is alive — kill it to reclaim the port
-            console.log(`[server] Killing PID ${pid} holding port ${port}`);
-            Bun.spawn(['taskkill', '/F', '/PID', String(pid)], { stdout: 'pipe', stderr: 'pipe' });
-            await Bun.sleep(1000);
-            return port;
-        } else {
-            // Process is dead but socket is zombie — use fallback port
-            const fallback = port + 1;
-            console.log(`[server] ⚠ Port ${port} held by zombie PID ${pid} — falling back to port ${fallback}`);
-            return fallback;
-        }
-    } catch { return port; /* best-effort cleanup */ }
-}
-
-let _originalPort = 3000;
-let _currentPort = 3000;
-
-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.
-    // When omitted, Melina defaults to 3000 with auto-fallback to next available port.
-    const requestedPort = process.env.BUN_PORT ? parseInt(process.env.BUN_PORT, 10) : 3000;
-    _originalPort = requestedPort;
-
-    // Clean up zombie port bindings before starting — may return a different fallback port
-    const resolvedPort = await cleanupPort(requestedPort);
-    _currentPort = resolvedPort;
-
-    // Pass port explicitly if user requested one OR if we had to fallback
-    const needsExplicitPort = process.env.BUN_PORT || resolvedPort !== requestedPort;
-    await start({
-        appDir,
-        defaultTitle: 'bgrun Dashboard - Process Manager',
-        globalCss: path.join(appDir, 'globals.css'),
-        ...(needsExplicitPort && { port: resolvedPort }),
-    });
-
-    // Start the built-in process guard
-    startGuard();
-
-    // Start log rotation (prevents unbounded log file growth)
-    const { startLogRotation } = await import('./log-rotation');
-    startLogRotation(() => getAllProcesses());
-
-    // Start sticky port checker - periodically try original port if we're on a fallback
-    if (resolvedPort !== requestedPort) {
-        startStickyPortChecker();
-    }
-}
-
-function startStickyPortChecker() {
-    const CHECK_INTERVAL_MS = 60_000; // Check every 60 seconds
-    console.log(`[server] Starting sticky port checker (original: ${_originalPort}, current: ${_currentPort})`);
-
-    setInterval(async () => {
-        if (_currentPort === _originalPort) return; // Already on original port
-
-        try {
-            const proc = Bun.spawn(['powershell', '-NoProfile', '-Command',
-                `Get-NetTCPConnection -LocalPort ${_originalPort} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`
-            ], { stdout: 'pipe', stderr: 'pipe' });
-            const text = await new Response(proc.stdout).text();
-            const pid = parseInt(text.trim(), 10);
-
-            if (!pid) {
-                console.log(`[server] ✓ Original port ${_originalPort} is now available! Consider restarting to reclaim it.`);
-                _currentPort = _originalPort;
-            }
-        } catch { /* best-effort */ }
-    }, CHECK_INTERVAL_MS);
-}
-
-/**
- * Built-in Process Guard
- * 
- * Runs as a background loop inside the dashboard process.
- * Every GUARD_INTERVAL_MS, checks processes with BGR_KEEP_ALIVE=true
- * in their env and auto-restarts any that died.
- * 
- * 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)`);
-
-    setInterval(async () => {
-        try {
-            const processes = getAllProcesses();
-            if (processes.length === 0) return;
-
-            for (const proc of processes) {
-                // 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) {
-                    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...`);
-                    let success = false;
-                    try {
-                        await handleRun({
-                            action: 'run',
-                            name: proc.name,
-                            force: true,
-                            remoteName: '',
-                        });
-                        success = true;
-
-                        // Track restart count
-                        const prevCount = guardRestartCounts.get(proc.name) || 0;
-                        const newCount = prevCount + 1;
-                        guardRestartCounts.set(proc.name, newCount);
-
-                        // Record in history database
-                        try {
-                            addHistoryEntry(proc.name, 'restart', undefined, { by: 'guard', count: newCount });
-                        } catch { /* ignore history errors */ }
-
-                        // Record event for dashboard
-                        guardEvents.unshift({ time: now, name: proc.name, action: 'restart', success: true });
-                        if (guardEvents.length > 100) guardEvents.pop();
-
-                        // 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}`);
-                        guardEvents.unshift({ time: now, name: proc.name, action: 'restart', success: false });
-                        if (guardEvents.length > 100) guardEvents.pop();
-                    }
-                } 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) {
-            console.error(`[guard] Error in guard loop: ${err.message}`);
-        }
-    }, GUARD_INTERVAL_MS);
-}

package/src/table.ts

@@ -1,232 +0,0 @@
-#!/usr/bin/env bun
-
-import chalk from "chalk";
-
-export interface TableColumn {
-  key: string;
-  header: string;
-  formatter?: (value: any) => string;
-  truncator?: (value: string, maxLength: number) => string;
-}
-
-export interface TableOptions {
-  maxWidth?: number;
-  padding?: number;
-  borderStyle?: "rounded" | "single" | "double" | "none";
-  showHeaders?: boolean;
-}
-
-export interface ProcessTableRow {
-  id: number;
-  pid: number;
-  name: string;
-  port: string;
-  memory: string;
-  command: string;
-  workdir: string;
-  status: string;
-  runtime: string;
-}
-
-// Get terminal width or use default
-export function getTerminalWidth(): number {
-  return process.stdout.columns || 120;
-}
-
-// Strip ANSI color codes for accurate length calculation
-export function stripAnsi(str: string): string {
-  return str.replace(/\u001b\[[0-9;]*m/g, "");
-}
-
-// Default truncator: trims the end of a string
-export function truncateString(str: string, maxLength: number): string {
-  const stripped = stripAnsi(str);
-  if (stripped.length <= maxLength) return str;
-  const ellipsis = "…";
-  // Ensure maxLength is at least 1 for the ellipsis
-  if (maxLength < 1) return "";
-  if (maxLength === 1) return ellipsis;
-
-  const targetLength = maxLength - ellipsis.length;
-  return str.substring(0, targetLength > 0 ? targetLength : 0) + ellipsis;
-}
-
-// Path truncator: trims the middle of a string
-export function truncatePath(str: string, maxLength: number): string {
-  const stripped = stripAnsi(str);
-  if (stripped.length <= maxLength) return str;
-  const ellipsis = "…";
-  // Ensure maxLength is at least 3 for a start, middle, and end character
-  if (maxLength < 3) return truncateString(str, maxLength);
-
-  const targetLength = maxLength - ellipsis.length;
-  const startLen = Math.ceil(targetLength / 2);
-  const endLen = Math.floor(targetLength / 2);
-  return str.substring(0, startLen) + ellipsis + str.substring(str.length - endLen);
-}
-
-// Calculate column widths by proportionally shrinking the widest columns
-export function calculateColumnWidths(
-  rows: any[],
-  columns: TableColumn[],
-  maxWidth: number,
-  padding: number = 2
-): Map<string, number> {
-  const separatorsWidth = columns.length + 1;
-  const paddingWidth = padding * columns.length;
-  const availableWidth = maxWidth - separatorsWidth - paddingWidth;
-
-  const naturalWidths = new Map<string, number>();
-
-  // 1. Calculate the natural width (max content length) for each column
-  for (const col of columns) {
-    let maxNatural = stripAnsi(col.header).length;
-    for (const row of rows) {
-      const value = col.formatter ? col.formatter(row[col.key]) : String(row[col.key] || "");
-      maxNatural = Math.max(maxNatural, stripAnsi(value).length);
-    }
-    naturalWidths.set(col.key, maxNatural);
-  }
-
-  const totalNaturalWidth = Array.from(naturalWidths.values()).reduce((sum, w) => sum + w, 0);
-
-  // 2. If it fits, we're done
-  if (totalNaturalWidth <= availableWidth) {
-    return naturalWidths;
-  }
-
-  // 3. If not, calculate the overage and shrink the widest columns iteratively
-  let overage = totalNaturalWidth - availableWidth;
-  const currentWidths = new Map(naturalWidths);
-
-  while (overage > 0) {
-    // Find the column that is currently the widest
-    let widestColKey: string | null = null;
-    let maxW = -1;
-    for (const [key, width] of currentWidths.entries()) {
-      if (width > maxW) {
-        maxW = width;
-        widestColKey = key;
-      }
-    }
-
-    // If no column can be shrunk (e.g., all are width 0), break
-    if (widestColKey === null || maxW <= 1) {
-      break;
-    }
-
-    // Shrink the widest column by 1
-    currentWidths.set(widestColKey, maxW - 1);
-    overage--;
-  }
-
-  return currentWidths;
-}
-
-function renderBorder(widths: number[], padding: number, style: string[]): string {
-  const [left, mid, right, line] = style;
-  let lineStr = left;
-  for (let i = 0; i < widths.length; i++) {
-    lineStr += line.repeat(widths[i] + padding);
-    if (i < widths.length - 1) {
-      lineStr += mid;
-    }
-  }
-  lineStr += right;
-  return lineStr;
-}
-
-export function renderHorizontalTable(
-  rows: any[],
-  columns: TableColumn[],
-  options: TableOptions = {}
-): { table: string; truncatedIndices: number[] } {
-  const { maxWidth = getTerminalWidth(), padding = 2, borderStyle = "rounded", showHeaders = true } = options;
-  if (rows.length === 0) return { table: chalk.gray("No data to display"), truncatedIndices: [] };
-
-  const borderChars: Record<string, string[]> = {
-    rounded: ["╭", "┬", "╮", "─", "│", "├", "┼", "┤", "╰", "┴", "╯"],
-    single: ["┌", "┬", "┐", "─", "│", "├", "┼", "┤", "└", "┴", "┘"],
-    double: ["╔", "╦", "╗", "═", "║", "╠", "╬", "╣", "╚", "╩", "╝"],
-    none: [" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "],
-  };
-  const [tl, tc, tr, h, v, ml, mc, mr, bl, bc, br] = borderChars[borderStyle] ?? borderChars.rounded;
-  const columnWidths = calculateColumnWidths(rows, columns, maxWidth, padding);
-  const widthArray = columns.map((col) => columnWidths.get(col.key)!);
-  const truncatedIndices = new Set<number>();
-  const lines: string[] = [];
-  const cellPadding = " ".repeat(padding / 2);
-
-  if (borderStyle !== "none") lines.push(renderBorder(widthArray, padding, [tl, tc, tr, h]));
-
-  if (showHeaders) {
-    const headerCells = columns.map((col, i) => chalk.bold(truncateString(col.header, widthArray[i]).padEnd(widthArray[i])));
-    lines.push(`${v}${cellPadding}${headerCells.join(`${cellPadding}${v}${cellPadding}`)}${cellPadding}${v}`);
-    if (borderStyle !== "none") lines.push(renderBorder(widthArray, padding, [ml, mc, mr, h]));
-  }
-
-  rows.forEach((row, rowIndex) => {
-    const cells = columns.map((col, i) => {
-      const width = widthArray[i];
-      const originalValue = col.formatter ? col.formatter(row[col.key]) : String(row[col.key] || "");
-      if (stripAnsi(originalValue).length > width) {
-        truncatedIndices.add(rowIndex);
-      }
-      const truncator = col.truncator || truncateString;
-      const truncated = truncator(originalValue, width);
-      return truncated + " ".repeat(Math.max(0, width - stripAnsi(truncated).length));
-    });
-    lines.push(`${v}${cellPadding}${cells.join(`${cellPadding}${v}${cellPadding}`)}${cellPadding}${v}`);
-  });
-
-  if (borderStyle !== "none") lines.push(renderBorder(widthArray, padding, [bl, bc, br, h]));
-
-  return { table: lines.join("\n"), truncatedIndices: Array.from(truncatedIndices) };
-}
-
-export function renderVerticalTree(rows: any[], columns: TableColumn[]): string {
-  const lines: string[] = [];
-  rows.forEach((row, index) => {
-    if (index > 0) lines.push("");
-    const name = row.name ? `'${row.name}'` : `(ID: ${row.id})`;
-    lines.push(chalk.cyan(`▶ ${name}`));
-
-    columns.forEach((col) => {
-      const value = col.formatter ? col.formatter(row[col.key]) : String(row[col.key] || "");
-      lines.push(`  ├─ ${chalk.gray(`${col.header}:`)} ${value}`);
-    });
-  });
-  return lines.join("\n");
-}
-
-export function renderHybridTable(
-  rows: any[],
-  columns: TableColumn[],
-  options: TableOptions = {}
-): string {
-  const { table, truncatedIndices } = renderHorizontalTable(rows, columns, options);
-  const output = [table];
-
-  if (truncatedIndices.length > 0) {
-    const truncatedRows = truncatedIndices.map((i) => rows[i]);
-    output.push("\n" + renderVerticalTree(truncatedRows, columns));
-  }
-
-  return output.join("\n");
-}
-
-export function renderProcessTable(processes: ProcessTableRow[], options?: TableOptions): string {
-  const columns: TableColumn[] = [
-    { key: "id", header: "ID", formatter: (id) => chalk.blue(id) },
-    { key: "pid", header: "PID", formatter: (pid) => chalk.yellow(pid) },
-    { key: "name", header: "Name", formatter: (name) => chalk.cyan.bold(name) },
-    { key: "port", header: "Port", formatter: (port) => port === '-' ? chalk.gray(port) : chalk.hex('#FF6B6B')(port) },
-    { key: "memory", header: "Memory", formatter: (mem) => mem === '-' ? chalk.gray(mem) : chalk.hex('#4ECDC4')(mem) },
-    { key: "command", header: "Command" },
-    { key: "workdir", header: "Directory", formatter: (dir) => chalk.gray(dir), truncator: truncatePath },
-    { key: "status", header: "Status" },
-    { key: "runtime", header: "Runtime", formatter: (runtime) => chalk.magenta(runtime) },
-  ];
-
-  return renderHybridTable(processes, columns, options);
-}

package/src/types.ts

@@ -1,14 +0,0 @@
-export interface CommandOptions {
-    remoteName?: string;
-    command?: string;
-    directory?: string;
-    env?: Record<string, string>;
-    configPath?: string;
-    action?: string;
-    name?: string;
-    force?: boolean;
-    fetch?: boolean;
-    stdout?: string;
-    stderr?: string;
-    dbPath?: string;
-}

package/src/utils.ts

@@ -1,96 +0,0 @@
-
-export function parseEnvString(envString: string): Record<string, string> {
-    const env: Record<string, string> = {};
-    envString.split(",").forEach(pair => {
-        const [key, value] = pair.split("=");
-        if (key && value) env[key] = value;
-    });
-    return env;
-}
-
-
-export function calculateRuntime(startTime: string): string {
-    const start = new Date(startTime).getTime();
-    const now = new Date().getTime();
-    const diffInMinutes = Math.floor((now - start) / (1000 * 60));
-    return `${diffInMinutes} minutes`;
-}
-
-// Re-export platform utils for backward compatibility and convenience
-export { isProcessRunning } from "./platform";
-
-import * as fs from "fs";
-import chalk from "chalk";
-
-// Read version at runtime instead of using macros (macros crash on Windows)
-export async function getVersion(): Promise<string> {
-    try {
-        const { join } = await import("path");
-        const pkgPath = join(import.meta.dir, '../package.json');
-        const pkg = await Bun.file(pkgPath).json();
-        return pkg.version || '0.0.0';
-    } catch {
-        return '0.0.0';
-    }
-}
-
-
-export function validateDirectory(directory: string) {
-    if (!directory || !fs.existsSync(directory)) {
-        // Throw instead of process.exit() — lets dashboard API handlers catch gracefully
-        throw new Error(`Directory not found or invalid: '${directory}'`);
-    }
-}
-
-export function tailFile(path: string, prefix: string, colorFn: (s: string) => string, lines?: number): () => void {
-    let position = 0;
-    let lastPartial = '';
-
-    if (!fs.existsSync(path)) {
-        return () => { };
-    }
-
-    const fd = fs.openSync(path, 'r');
-
-    const printNewContent = () => {
-        try {
-            const stats = fs.statSync(path);
-            if (stats.size <= position) return;
-
-            const buffer = Buffer.alloc(stats.size - position);
-            fs.readSync(fd, buffer, 0, buffer.length, position);
-
-            let content = buffer.toString();
-            content = lastPartial + content;
-            lastPartial = '';
-
-            const lineArray = content.split(/\r?\n/);
-            if (!content.endsWith('\n')) {
-                lastPartial = lineArray.pop() || '';
-            }
-
-            lineArray.forEach(line => {
-                if (line) {
-                    console.log(colorFn(prefix + line));
-                }
-            });
-
-            position = stats.size;
-        } catch (e) {
-            // ignore read errors
-        }
-    };
-
-    const watcher = fs.watch(path, { persistent: true }, (event) => {
-        if (event === 'change') {
-            printNewContent();
-        }
-    });
-
-    printNewContent(); // Check immediately
-
-    return () => {
-        watcher.close();
-        try { fs.closeSync(fd); } catch { }
-    };
-}