bgrun 3.10.2 → 3.12.0

package/package.json

@@ -1,60 +1,62 @@
-{
-  "name": "bgrun",
-  "version": "3.10.2",
-  "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"
-  }
-}
+{
+  "name": "bgrun",
+  "version": "3.12.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",
+    "scripts",
+    "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": {
+    "@types/bun": "^1.3.10",
+    "bun-types": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
+    "dedent": "^1.5.3",
+    "measure-fn": "3.10.1",
+    "melina": "2.3.6",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "sqlite-zod-orm": "3.26.1"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}

package/scripts/bgr-startup.ps1

@@ -0,0 +1,118 @@
+# bgr-startup.ps1 — Auto-start bgrun guard on Windows login
+# Ensures all guarded processes (and the dashboard itself) start on boot.
+#
+# Installation:
+#   1. Run this script once with -Install flag:
+#      powershell -ExecutionPolicy Bypass -File bgr-startup.ps1 -Install
+#
+#   2. Or manually create a Task Scheduler task:
+#      - Trigger: At log on
+#      - Action: powershell -WindowStyle Hidden -ExecutionPolicy Bypass -File "C:\Code\bgr\scripts\bgr-startup.ps1"
+#      - Run whether user is logged on or not: Yes
+#
+# Usage:
+#   bgr-startup.ps1           # Start bgrun guard
+#   bgr-startup.ps1 -Install  # Register Task Scheduler entry
+
+param(
+    [switch]$Install
+)
+
+$BunPath = "$env:USERPROFILE\.bun\bin\bun.exe"
+$BgrunPath = "C:\Code\bgr"
+$LogPath = "$env:USERPROFILE\.bgr\startup.log"
+
+function Write-Log {
+    param([string]$Message)
+    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+    $line = "[$timestamp] $Message"
+    Write-Host $line
+    Add-Content -Path $LogPath -Value $line -ErrorAction SilentlyContinue
+}
+
+# Ensure .bgr directory exists
+$bgrDir = "$env:USERPROFILE\.bgr"
+if (-not (Test-Path $bgrDir)) {
+    New-Item -ItemType Directory -Path $bgrDir -Force | Out-Null
+}
+
+if ($Install) {
+    Write-Log "Installing bgrun auto-start task..."
+
+    $scriptPath = $PSCommandPath
+    if (-not $scriptPath) {
+        $scriptPath = Join-Path $BgrunPath "scripts\bgr-startup.ps1"
+    }
+
+    # Remove existing task if present
+    $existingTask = Get-ScheduledTask -TaskName "bgrun-guard" -ErrorAction SilentlyContinue
+    if ($existingTask) {
+        Unregister-ScheduledTask -TaskName "bgrun-guard" -Confirm:$false
+        Write-Log "Removed existing bgrun-guard task"
+    }
+
+    # Create the scheduled task
+    $action = New-ScheduledTaskAction `
+        -Execute "powershell.exe" `
+        -Argument "-WindowStyle Hidden -ExecutionPolicy Bypass -File `"$scriptPath`""
+
+    $trigger = New-ScheduledTaskTrigger -AtLogon
+    $settings = New-ScheduledTaskSettingsSet `
+        -AllowStartIfOnBatteries `
+        -DontStopIfGoingOnBatteries `
+        -StartWhenAvailable `
+        -RestartInterval (New-TimeSpan -Minutes 5) `
+        -RestartCount 3
+
+    Register-ScheduledTask `
+        -TaskName "bgrun-guard" `
+        -Description "bgrun process manager — auto-starts all guarded processes on login" `
+        -Action $action `
+        -Trigger $trigger `
+        -Settings $settings `
+        -RunLevel Highest `
+        -Force
+
+    Write-Log "✓ Task 'bgrun-guard' registered. Will start on next login."
+    Write-Log "  Script: $scriptPath"
+    exit 0
+}
+
+# ── Main: Start bgrun guard ─────────────────────────────────
+Write-Log "bgrun startup initiated"
+
+# Check bun exists
+if (-not (Test-Path $BunPath)) {
+    Write-Log "ERROR: bun not found at $BunPath"
+    exit 1
+}
+
+# Check bgrun repo exists
+if (-not (Test-Path "$BgrunPath\src\guard.ts")) {
+    Write-Log "ERROR: bgrun not found at $BgrunPath"
+    exit 1
+}
+
+# Start the dashboard first (guard needs it)
+Write-Log "Starting bgrun dashboard..."
+$dashboardProc = Start-Process -FilePath $BunPath `
+    -ArgumentList "run", "$BgrunPath\src\index.ts", "--dashboard", "--port", "3000" `
+    -WindowStyle Hidden `
+    -PassThru `
+    -WorkingDirectory $BgrunPath
+
+Write-Log "Dashboard PID: $($dashboardProc.Id)"
+
+# Wait for dashboard to be ready
+Start-Sleep -Seconds 5
+
+# Start the guard (watches dashboard + all guarded processes)
+Write-Log "Starting bgrun guard..."
+$guardProc = Start-Process -FilePath $BunPath `
+    -ArgumentList "run", "$BgrunPath\src\index.ts", "--guard" `
+    -WindowStyle Hidden `
+    -PassThru `
+    -WorkingDirectory $BgrunPath
+
+Write-Log "Guard PID: $($guardProc.Id)"
+Write-Log "✓ bgrun startup complete. Dashboard: $($dashboardProc.Id), Guard: $($guardProc.Id)"

package/src/api.ts

@@ -39,7 +39,7 @@ export {
     ensureDir,
     getHomeDir,
     isWindows,
-    getProcessBatchMemory,
+    getProcessBatchResources,
     getProcessMemory
 } from './platform'
 
@@ -51,13 +51,13 @@ export { getVersion, calculateRuntime, parseEnvString, validateDirectory } from
 
 // --- 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 { isProcessRunning, terminateProcess, readFileTail, getProcessPorts, findChildPid, findPidByPort, getShellCommand, killProcessOnPort, waitForPortFree, ensureDir, getHomeDir, isWindows, getProcessBatchResources, 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,
+    isProcessRunning, terminateProcess, readFileTail, getProcessPorts, findChildPid, findPidByPort, getShellCommand, killProcessOnPort, waitForPortFree, ensureDir, getHomeDir, isWindows, getProcessBatchResources, getProcessMemory,
     handleRun,
     getVersion, calculateRuntime, parseEnvString, validateDirectory,
 }

package/src/bgrun.test.ts

@@ -0,0 +1,109 @@
+/**
+ * bgrun core utility tests
+ *
+ * Tests pure logic functions: env parsing, config flattening,
+ * string truncation, and runtime calculation.
+ *
+ * Run: bun test src/bgrun.test.ts
+ */
+import { describe, expect, test } from 'bun:test'
+import { parseEnvString, calculateRuntime } from './utils'
+import { stripAnsi, truncateString, truncatePath } from './table'
+
+// ─── parseEnvString ─────────────────────────────────────
+
+describe('parseEnvString', () => {
+    test('parses comma-separated key=value pairs', () => {
+        const result = parseEnvString('PORT=3000,HOST=localhost,DEBUG=true')
+        expect(result).toEqual({
+            PORT: '3000',
+            HOST: 'localhost',
+            DEBUG: 'true',
+        })
+    })
+
+    test('handles single pair', () => {
+        expect(parseEnvString('KEY=value')).toEqual({ KEY: 'value' })
+    })
+
+    test('handles empty string', () => {
+        expect(parseEnvString('')).toEqual({})
+    })
+
+    test('ignores malformed pairs (no =)', () => {
+        const result = parseEnvString('GOOD=yes,BAD,ALSO_GOOD=ok')
+        expect(result.GOOD).toBe('yes')
+        expect(result.ALSO_GOOD).toBe('ok')
+        expect(result.BAD).toBeUndefined()
+    })
+})
+
+// ─── calculateRuntime ───────────────────────────────────
+
+describe('calculateRuntime', () => {
+    test('returns 0 minutes for recent start', () => {
+        const now = new Date().toISOString()
+        expect(calculateRuntime(now)).toBe('0 minutes')
+    })
+
+    test('returns correct minutes', () => {
+        const fiveMinAgo = new Date(Date.now() - 5 * 60 * 1000).toISOString()
+        expect(calculateRuntime(fiveMinAgo)).toBe('5 minutes')
+    })
+
+    test('returns correct for 1 hour', () => {
+        const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString()
+        expect(calculateRuntime(oneHourAgo)).toBe('60 minutes')
+    })
+})
+
+// ─── stripAnsi ──────────────────────────────────────────
+
+describe('stripAnsi', () => {
+    test('strips color codes', () => {
+        const colored = '\u001b[31mred text\u001b[0m'
+        expect(stripAnsi(colored)).toBe('red text')
+    })
+
+    test('passes through plain text', () => {
+        expect(stripAnsi('hello world')).toBe('hello world')
+    })
+
+    test('handles empty string', () => {
+        expect(stripAnsi('')).toBe('')
+    })
+})
+
+// ─── truncateString ─────────────────────────────────────
+
+describe('truncateString', () => {
+    test('returns string unchanged if within limit', () => {
+        expect(truncateString('hello', 10)).toBe('hello')
+    })
+
+    test('truncates with ellipsis', () => {
+        const result = truncateString('a very long string that exceeds limit', 15)
+        expect(result.length).toBeLessThanOrEqual(15)
+        expect(result).toContain('…')
+    })
+
+    test('handles maxLength smaller than ellipsis', () => {
+        const result = truncateString('hello world', 2)
+        expect(result.length).toBeLessThanOrEqual(2)
+    })
+})
+
+// ─── truncatePath ───────────────────────────────────────
+
+describe('truncatePath', () => {
+    test('returns path unchanged if within limit', () => {
+        expect(truncatePath('/home/user', 50)).toBe('/home/user')
+    })
+
+    test('truncates middle of long path', () => {
+        const longPath = '/home/user/projects/very/deeply/nested/directory/structure'
+        const result = truncatePath(longPath, 30)
+        expect(result.length).toBeLessThanOrEqual(30)
+        expect(result).toContain('…')
+    })
+})

package/src/commands/list.ts

@@ -4,7 +4,7 @@ import type { ProcessTableRow } from "../table";
 import { getAllProcesses } from "../db";
 import { announce } from "../logger";
 import { isProcessRunning, calculateRuntime, parseEnvString } from "../utils";
-import { getProcessPorts, getProcessBatchMemory } from "../platform";
+import { getProcessPorts, getProcessBatchResources } from "../platform";
 import { measure } from "measure-fn";
 
 function formatMemory(bytes: number): string {
@@ -51,12 +51,12 @@ export async function showAll(opts?: { json?: boolean; filter?: string }) {
 
     // Batch fetch memory for all PIDs
     const allPids = filtered.map(p => p.pid);
-    const memoryMap = await getProcessBatchMemory(allPids);
+    const resourceMap = await getProcessBatchResources(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 mem = isRunning ? (resourceMap.get(proc.pid)?.memory || 0) : 0;
 
         const ports = isRunning ? await getProcessPorts(proc.pid) : [];
         tableData.push({

package/src/commands/run.ts

@@ -17,6 +17,23 @@ export async function handleRun(options: CommandOptions) {
 
     const existingProcess = name ? getProcess(name) : null;
 
+    // Auto-start unmet dependencies before starting this process
+    if (name && existingProcess) {
+        const { getUnmetDeps } = await import('../deps');
+        const unmet = await getUnmetDeps(name);
+        if (unmet.length > 0) {
+            await run.measure(`Start ${unmet.length} dependencies for "${name}"`, async () => {
+                for (const depName of unmet) {
+                    const depProc = getProcess(depName);
+                    if (depProc) {
+                        announce(`📦 Starting dependency "${depName}" for "${name}"`, 'Dependency');
+                        await handleRun({ action: 'run', name: depName, force: true, remoteName: '' });
+                    }
+                }
+            });
+        }
+    }
+
     if (existingProcess) {
         const finalDirectory = directory || existingProcess.workdir;
         validateDirectory(finalDirectory);

package/src/deps.ts

@@ -0,0 +1,126 @@
+/**
+ * Process Dependency Graph
+ * 
+ * Defines and resolves process startup dependencies.
+ * Dependencies are stored in process env as BGR_DEPENDS_ON=name1,name2
+ * 
+ * Features:
+ * - Topological sort for startup order
+ * - Cycle detection
+ * - Dependency graph as adjacency list
+ * - Auto-start dependencies on process run
+ */
+
+import { getAllProcesses, getProcess } from './db'
+import { isProcessRunning } from './platform'
+import { parseEnvString } from './utils'
+
+export interface DepNode {
+    name: string
+    dependsOn: string[]      // processes this depends ON (must start first)
+    dependedBy: string[]     // processes that depend on THIS
+    running: boolean
+    pid: number
+}
+
+export interface DepGraph {
+    nodes: DepNode[]
+    order: string[]          // topological sort (startup order)
+    hasCycle: boolean
+    cycleNodes?: string[]    // nodes involved in cycle
+}
+
+/** Parse BGR_DEPENDS_ON from a process env string */
+export function getDependencies(envStr: string): string[] {
+    const env = parseEnvString(envStr)
+    const raw = env.BGR_DEPENDS_ON || ''
+    return raw.split(',').map(s => s.trim()).filter(Boolean)
+}
+
+/** Build the full dependency graph from all registered processes */
+export async function buildDepGraph(): Promise<DepGraph> {
+    const processes = getAllProcesses()
+    const nodeMap = new Map<string, DepNode>()
+
+    // Phase 1: Create all nodes
+    for (const proc of processes) {
+        const deps = getDependencies(proc.env)
+        const alive = await isProcessRunning(proc.pid, proc.command)
+        nodeMap.set(proc.name, {
+            name: proc.name,
+            dependsOn: deps,
+            dependedBy: [],
+            running: alive,
+            pid: proc.pid,
+        })
+    }
+
+    // Phase 2: Build reverse edges (dependedBy)
+    for (const node of nodeMap.values()) {
+        for (const dep of node.dependsOn) {
+            const depNode = nodeMap.get(dep)
+            if (depNode) {
+                depNode.dependedBy.push(node.name)
+            }
+        }
+    }
+
+    // Phase 3: Topological sort (Kahn's algorithm)
+    const inDegree = new Map<string, number>()
+    for (const node of nodeMap.values()) {
+        inDegree.set(node.name, node.dependsOn.filter(d => nodeMap.has(d)).length)
+    }
+
+    const queue: string[] = []
+    for (const [name, degree] of inDegree) {
+        if (degree === 0) queue.push(name)
+    }
+
+    const order: string[] = []
+    while (queue.length > 0) {
+        const current = queue.shift()!
+        order.push(current)
+
+        const node = nodeMap.get(current)!
+        for (const dependent of node.dependedBy) {
+            const newDegree = (inDegree.get(dependent) || 0) - 1
+            inDegree.set(dependent, newDegree)
+            if (newDegree === 0) queue.push(dependent)
+        }
+    }
+
+    const hasCycle = order.length < nodeMap.size
+    const cycleNodes = hasCycle
+        ? [...nodeMap.keys()].filter(n => !order.includes(n))
+        : undefined
+
+    return {
+        nodes: [...nodeMap.values()],
+        order,
+        hasCycle,
+        cycleNodes,
+    }
+}
+
+/** Get unmet dependencies for a specific process */
+export async function getUnmetDeps(name: string): Promise<string[]> {
+    const proc = getProcess(name)
+    if (!proc) return []
+
+    const deps = getDependencies(proc.env)
+    const unmet: string[] = []
+
+    for (const depName of deps) {
+        const depProc = getProcess(depName)
+        if (!depProc) {
+            unmet.push(depName) // dependency not even registered
+            continue
+        }
+        const alive = await isProcessRunning(depProc.pid, depProc.command)
+        if (!alive) {
+            unmet.push(depName)
+        }
+    }
+
+    return unmet
+}