bgrun 3.12.0 → 3.12.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bgrun",
-  "version": "3.12.0",
+  "version": "3.12.2",
   "description": "bgrun — A lightweight process manager for Bun",
   "type": "module",
   "main": "./src/api.ts",
@@ -59,4 +59,4 @@
   "engines": {
     "bun": ">=1.0.0"
   }
-}
+}

package/scripts/bgr-startup.ps1

@@ -66,14 +66,14 @@ if ($Install) {
 
     Register-ScheduledTask `
         -TaskName "bgrun-guard" `
-        -Description "bgrun process manager — auto-starts all guarded processes on login" `
+        -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 "[OK] Task 'bgrun-guard' registered. Will start on next login."
     Write-Log "  Script: $scriptPath"
     exit 0
 }
@@ -115,4 +115,4 @@ $guardProc = Start-Process -FilePath $BunPath `
     -WorkingDirectory $BgrunPath
 
 Write-Log "Guard PID: $($guardProc.Id)"
-Write-Log "✓ bgrun startup complete. Dashboard: $($dashboardProc.Id), Guard: $($guardProc.Id)"
+Write-Log "[OK] bgrun startup complete. Dashboard: $($dashboardProc.Id), Guard: $($guardProc.Id)"

package/scripts/bgrun-startup.ps1

@@ -0,0 +1,91 @@
+# bgrun-startup.ps1 — Persistent bgr-dashboard launcher
+# Ensures the bgrun dashboard survives terminal closures.
+# Individual services (geeksy, mm-dash, galaxy-canvas, etc.) are managed
+# by bgr-guard INSIDE the dashboard — this script only keeps the dashboard alive.
+#
+# Usage:
+#   .\bgrun-startup.ps1                  # Start bgr-dashboard
+#   .\bgrun-startup.ps1 -Install         # Register as logon scheduled task
+#   .\bgrun-startup.ps1 -Uninstall       # Remove scheduled task
+#   .\bgrun-startup.ps1 -Guard           # Run guard loop (auto-restart dashboard)
+
+param(
+    [switch]$Install,
+    [switch]$Uninstall,
+    [switch]$Guard
+)
+
+$TaskName = "bgrun-persistence"
+$ScriptPath = $MyInvocation.MyCommand.Path
+
+# ─── Install as Scheduled Task ────────────────────────────
+if ($Install) {
+    $action = New-ScheduledTaskAction `
+        -Execute "pwsh.exe" `
+        -Argument "-WindowStyle Hidden -NonInteractive -File `"$ScriptPath`" -Guard"
+    
+    $trigger = New-ScheduledTaskTrigger -AtLogOn -User $env:USERNAME
+    $settings = New-ScheduledTaskSettingsSet `
+        -AllowStartIfOnBatteries `
+        -DontStopIfGoingOnBatteries `
+        -StartWhenAvailable `
+        -RestartInterval (New-TimeSpan -Minutes 1) `
+        -RestartCount 3 `
+        -ExecutionTimeLimit (New-TimeSpan -Hours 0)  # No time limit
+
+    Register-ScheduledTask `
+        -TaskName $TaskName `
+        -Action $action `
+        -Trigger $trigger `
+        -Settings $settings `
+        -Description "Keeps bgr-dashboard alive across terminal closures. Dashboard's own bgr-guard handles individual services." `
+        -Force
+
+    Write-Host "✅ Scheduled task '$TaskName' registered for user $env:USERNAME"
+    Write-Host "   Runs at logon — keeps bgr-dashboard alive"
+    Write-Host "   To start immediately: schtasks /run /tn '$TaskName'"
+    exit 0
+}
+
+# ─── Uninstall ────────────────────────────────────────────
+if ($Uninstall) {
+    Unregister-ScheduledTask -TaskName $TaskName -Confirm:$false -ErrorAction SilentlyContinue
+    Write-Host "🗑️  Scheduled task '$TaskName' removed"
+    exit 0
+}
+
+# ─── Guard mode: keep bgr-dashboard alive ─────────────────
+if ($Guard) {
+    Write-Host "🛡️  bgrun dashboard guard started at $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')"
+    
+    while ($true) {
+        try {
+            $dashboard = & bgrun --json 2>$null | ConvertFrom-Json | Where-Object { $_.name -eq 'bgr-dashboard' }
+            
+            if (-not $dashboard -or $dashboard.status -ne "running") {
+                Write-Host "[$(Get-Date -Format 'HH:mm:ss')] ⚠️  bgr-dashboard is DOWN — restarting..."
+                & bgrun --restart bgr-dashboard --force 2>$null
+                Start-Sleep -Seconds 3
+            }
+        } catch {
+            Write-Host "[$(Get-Date -Format 'HH:mm:ss')] ❌ Guard check failed: $_"
+        }
+        
+        Start-Sleep -Seconds 60
+    }
+    exit 0
+}
+
+# ─── Default: one-time start ──────────────────────────────
+Write-Host "🚀 Starting bgr-dashboard..."
+$dashboard = & bgrun --json 2>$null | ConvertFrom-Json | Where-Object { $_.name -eq 'bgr-dashboard' }
+if ($dashboard -and $dashboard.status -eq "running") {
+    Write-Host "  ✓ bgr-dashboard already running (PID $($dashboard.pid))"
+} else {
+    & bgrun --restart bgr-dashboard --force 2>$null
+    Start-Sleep -Seconds 2
+    Write-Host "  ✓ bgr-dashboard started"
+}
+Write-Host "`n✅ Done. Dashboard's bgr-guard handles individual services."
+Write-Host "   💡 Run with -Install to persist across terminal closures"
+

package/src/bgrun.test.ts

@@ -9,6 +9,13 @@
 import { describe, expect, test } from 'bun:test'
 import { parseEnvString, calculateRuntime } from './utils'
 import { stripAnsi, truncateString, truncatePath } from './table'
+import { detectPackageManager, formatDeployToolError } from './deploy'
+import { isProcessRunning } from './platform'
+import { mkdirSync, rmSync } from 'fs'
+
+// Use a test-specific database to avoid polluting real data
+process.env.BGRUN_DB = `bgrun-test-${Date.now()}.sqlite`
+import { addDependency, removeDependency, getDependencyGraph, getDependencies, getDependents, getStartOrder, removeAllDependencies } from './db'
 
 // ─── parseEnvString ─────────────────────────────────────
 
@@ -107,3 +114,167 @@ describe('truncatePath', () => {
         expect(result).toContain('…')
     })
 })
+
+// ─── detectPackageManager ───────────────────────────────
+
+// ─── isProcessRunning (Windows liveness fallback) ───────
+
+describe('isProcessRunning', () => {
+    test('returns true for the current process PID', async () => {
+        const alive = await isProcessRunning(process.pid)
+        expect(alive).toBe(true)
+    })
+
+    test('returns false for PID 0 (intentionally stopped)', async () => {
+        const alive = await isProcessRunning(0)
+        expect(alive).toBe(false)
+    })
+
+    test('returns false for a very high unlikely PID', async () => {
+        const alive = await isProcessRunning(999999)
+        expect(alive).toBe(false)
+    })
+
+    test('returns false for negative PID', async () => {
+        const alive = await isProcessRunning(-1)
+        expect(alive).toBe(false)
+    })
+})
+
+// ─── detectPackageManager ───────────────────────────────
+
+describe('formatDeployToolError', () => {
+    test('returns actionable message for missing binary', () => {
+        const msg = formatDeployToolError('pnpm', new Error('command not found: pnpm'))
+        expect(msg).toContain("requires 'pnpm'")
+        expect(msg).toContain('PATH')
+    })
+
+    test('preserves non-missing-binary failures', () => {
+        const msg = formatDeployToolError('npm', new Error('npm ci failed with exit code 1'))
+        expect(msg).toContain('Dependency install failed with npm')
+        expect(msg).toContain('exit code 1')
+    })
+})
+
+describe('detectPackageManager', () => {
+    test('returns null when no package.json exists', async () => {
+        const dir = `${process.cwd()}/tmp-no-package-${Date.now()}`
+        mkdirSync(dir, { recursive: true })
+        try {
+            expect(await detectPackageManager(dir)).toBeNull()
+        } finally {
+            rmSync(dir, { recursive: true, force: true })
+        }
+    })
+
+    test('prefers bun lockfiles', async () => {
+        const dir = `${process.cwd()}/tmp-bun-${Date.now()}`
+        mkdirSync(dir, { recursive: true })
+        try {
+            await Bun.write(`${dir}/package.json`, '{}')
+            await Bun.write(`${dir}/bun.lock`, '')
+            expect(await detectPackageManager(dir)).toBe('bun')
+        } finally {
+            rmSync(dir, { recursive: true, force: true })
+        }
+    })
+
+    test('detects pnpm, yarn, and npm lockfiles', async () => {
+        const base = `${process.cwd()}/tmp-pm-${Date.now()}`
+
+        const pnpmDir = `${base}-pnpm`
+        mkdirSync(pnpmDir, { recursive: true })
+        await Bun.write(`${pnpmDir}/package.json`, '{}')
+        await Bun.write(`${pnpmDir}/pnpm-lock.yaml`, '')
+        expect(await detectPackageManager(pnpmDir)).toBe('pnpm')
+
+        const yarnDir = `${base}-yarn`
+        mkdirSync(yarnDir, { recursive: true })
+        await Bun.write(`${yarnDir}/package.json`, '{}')
+        await Bun.write(`${yarnDir}/yarn.lock`, '')
+        expect(await detectPackageManager(yarnDir)).toBe('yarn')
+
+        const npmDir = `${base}-npm`
+        mkdirSync(npmDir, { recursive: true })
+        await Bun.write(`${npmDir}/package.json`, '{}')
+        await Bun.write(`${npmDir}/package-lock.json`, '{}')
+        expect(await detectPackageManager(npmDir)).toBe('npm')
+
+        rmSync(pnpmDir, { recursive: true, force: true })
+        rmSync(yarnDir, { recursive: true, force: true })
+        rmSync(npmDir, { recursive: true, force: true })
+    })
+
+    test('defaults to bun for package.json projects without a lockfile', async () => {
+        const dir = `${process.cwd()}/tmp-default-bun-${Date.now()}`
+        mkdirSync(dir, { recursive: true })
+        try {
+            await Bun.write(`${dir}/package.json`, '{}')
+            expect(await detectPackageManager(dir)).toBe('bun')
+        } finally {
+            rmSync(dir, { recursive: true, force: true })
+        }
+    })
+})
+
+// ─── Dependencies ───────────────────────────────────────
+
+describe('addDependency', () => {
+    test('adds a valid dependency', () => {
+        removeAllDependencies('web-server');
+        removeAllDependencies('database');
+        const ok = addDependency('web-server', 'database');
+        expect(ok).toBe(true);
+        expect(getDependencies('web-server')).toContain('database');
+    })
+
+    test('prevents self-dependency', () => {
+        expect(addDependency('api', 'api')).toBe(false);
+    })
+
+    test('prevents duplicate dependency', () => {
+        removeAllDependencies('app');
+        addDependency('app', 'db');
+        expect(addDependency('app', 'db')).toBe(false);
+    })
+
+    test('prevents circular dependency', () => {
+        removeAllDependencies('a');
+        removeAllDependencies('b');
+        removeAllDependencies('c');
+        addDependency('a', 'b');
+        addDependency('b', 'c');
+        // c -> a would create a cycle
+        expect(addDependency('c', 'a')).toBe(false);
+    })
+})
+
+describe('getDependencyGraph', () => {
+    test('returns full graph', () => {
+        removeAllDependencies('svc-a');
+        removeAllDependencies('svc-b');
+        addDependency('svc-a', 'svc-b');
+        const graph = getDependencyGraph();
+        expect(graph['svc-a']).toContain('svc-b');
+    })
+})
+
+describe('getDependents', () => {
+    test('finds processes that depend on a target', () => {
+        removeAllDependencies('frontend');
+        removeAllDependencies('backend');
+        addDependency('frontend', 'backend');
+        expect(getDependents('backend')).toContain('frontend');
+    })
+})
+
+describe('removeDependency', () => {
+    test('removes an existing dependency', () => {
+        removeAllDependencies('x');
+        addDependency('x', 'y');
+        expect(getDependencies('x')).toContain('y');
+        removeDependency('x', 'y');
+        expect(getDependencies('x')).not.toContain('y');
+    })
+})

package/src/commands/details.ts

@@ -1,8 +1,8 @@
 
 import { error, announce } from "../logger";
-import { getProcess } from "../db";
+import { getProcess, updateProcessPid } from "../db";
 import { isProcessRunning, calculateRuntime, parseEnvString } from "../utils";
-import { getProcessPorts } from "../platform";
+import { getProcessPorts, reconcileProcessPids } from "../platform";
 import chalk from "chalk";
 
 export async function showDetails(name: string) {
@@ -12,7 +12,21 @@ export async function showDetails(name: string) {
         return;
     }
 
-    const isRunning = await isProcessRunning(proc.pid, proc.command);
+    let isRunning = await isProcessRunning(proc.pid, proc.command);
+
+    // Reconcile stale PID: cmd.exe wrapper may have exited while bun.exe child lives
+    if (!isRunning && proc.pid > 0) {
+        const reconciled = await reconcileProcessPids(
+            [{ name: proc.name, pid: proc.pid, command: proc.command, workdir: proc.workdir }],
+            new Set([proc.pid]),
+        );
+        const newPid = reconciled.get(proc.name);
+        if (newPid) {
+            updateProcessPid(proc.name, newPid);
+            (proc as any).pid = newPid;
+            isRunning = true;
+        }
+    }
     const runtime = calculateRuntime(proc.timestamp);
     const envVars = parseEnvString(proc.env);
 

package/src/commands/list.ts

@@ -1,10 +1,10 @@
 import chalk from "chalk";
 import { renderProcessTable } from "../table";
 import type { ProcessTableRow } from "../table";
-import { getAllProcesses } from "../db";
+import { getAllProcesses, updateProcessPid } from "../db";
 import { announce } from "../logger";
 import { isProcessRunning, calculateRuntime, parseEnvString } from "../utils";
-import { getProcessPorts, getProcessBatchResources } from "../platform";
+import { getProcessPorts, getProcessBatchResources, reconcileProcessPids } from "../platform";
 import { measure } from "measure-fn";
 
 function formatMemory(bytes: number): string {
@@ -24,12 +24,45 @@ export async function showAll(opts?: { json?: boolean; filter?: string }) {
         return envVars["BGR_GROUP"] === opts.filter;
     });
 
+    // ─── PID Reconciliation ──────────────────────────────────────────
+    // On Windows, the stored PID may be a dead cmd.exe wrapper while the
+    // actual bun.exe child is still running.  Detect dead PIDs up-front,
+    // reconcile them in one batch PowerShell call, and patch the DB so
+    // subsequent invocations are stable (no flicker).
+    const deadPids = new Set<number>();
+    const aliveCache = new Map<number, boolean>();
+
+    for (const proc of filtered) {
+        const alive = await isProcessRunning(proc.pid, proc.command);
+        aliveCache.set(proc.pid, alive);
+        if (!alive && proc.pid > 0) deadPids.add(proc.pid);
+    }
+
+    if (deadPids.size > 0) {
+        const reconciled = await reconcileProcessPids(
+            filtered.map(p => ({ name: p.name, pid: p.pid, command: p.command, workdir: p.workdir })),
+            deadPids,
+        );
+
+        for (const [name, newPid] of reconciled) {
+            updateProcessPid(name, newPid);
+            // Patch the in-memory record so the rest of this function sees
+            // the corrected PID without re-querying the DB.
+            const proc = filtered.find(p => p.name === name);
+            if (proc) {
+                (proc as any).pid = newPid;
+                aliveCache.set(newPid, true);
+            }
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────
+
     if (opts?.json) {
         // JSON output with filtered env variables
         const jsonData: any[] = [];
 
         for (const proc of filtered) {
-            const isRunning = await isProcessRunning(proc.pid, proc.command);
+            const isRunning = aliveCache.get(proc.pid) ?? await isProcessRunning(proc.pid, proc.command);
             const envVars = parseEnvString(proc.env);
 
             const ports = isRunning ? await getProcessPorts(proc.pid) : [];
@@ -54,7 +87,7 @@ export async function showAll(opts?: { json?: boolean; filter?: string }) {
     const resourceMap = await getProcessBatchResources(allPids);
 
     for (const proc of filtered) {
-        const isRunning = await isProcessRunning(proc.pid, proc.command);
+        const isRunning = aliveCache.get(proc.pid) ?? await isProcessRunning(proc.pid, proc.command);
         const runtime = calculateRuntime(proc.timestamp);
         const mem = isRunning ? (resourceMap.get(proc.pid)?.memory || 0) : 0;
 

package/src/commands/run.ts

@@ -1,6 +1,6 @@
 import type { CommandOptions } from "../types";
 import { getProcess, removeProcessByName, retryDatabaseOperation, insertProcess } from "../db";
-import { isProcessRunning, terminateProcess, getHomeDir, getShellCommand, killProcessOnPort, findChildPid, getProcessPorts, waitForPortFree } from "../platform";
+import { isProcessRunning, terminateProcess, getHomeDir, getShellCommand, killProcessOnPort, findChildPid, getProcessPorts, waitForPortFree, psExec } from "../platform";
 import { error, announce } from "../logger";
 import { validateDirectory, parseEnvString } from "../utils";
 import { parseConfigFile } from "../config";
@@ -95,12 +95,25 @@ export async function handleRun(options: CommandOptions) {
 
         // Zombie sweep: kill any remaining bun processes matching this command
         // This catches orphaned children that survived taskkill when the parent shell exited
+        // IMPORTANT: Exclude the current bgrun process and dashboard to avoid self-kill
         const cmdToMatch = existingProcess.command;
         if (cmdToMatch) {
             await run.measure('Zombie sweep', async () => {
                 try {
-                    const result = await $`powershell -Command "Get-Process -Name bun -ErrorAction SilentlyContinue | Where-Object { $_.CommandLine -match '${cmdToMatch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').split(' ')[1] || cmdToMatch}' } | Select-Object -ExpandProperty Id"`.nothrow().text();
-                    const zombiePids = result.split('\n').map((l: string) => parseInt(l.trim())).filter((n: number) => !isNaN(n) && n > 0);
+                    const cmdKeyword = cmdToMatch.split(' ')[1] || cmdToMatch;
+                    // Skip sweep if keyword is too generic (would match unrelated processes)
+                    const GENERIC_KEYWORDS = ['dev', 'run', 'start', 'serve', 'build', 'test'];
+                    if (GENERIC_KEYWORDS.includes(cmdKeyword.toLowerCase())) {
+                        return; // Too dangerous — skip zombie sweep for generic commands
+                    }
+                    const currentPid = process.pid;
+                    const result = await psExec(
+                        `Get-CimInstance Win32_Process -Filter "Name='bun.exe'" | Where-Object { $_.CommandLine -match '${cmdKeyword.replace(/'/g, "''")}' -and $_.ProcessId -ne ${currentPid} } | Select-Object -ExpandProperty ProcessId`,
+                        3000
+                    );
+                    const zombiePids = result.split('\n')
+                        .map((l: string) => parseInt(l.trim()))
+                        .filter((n: number) => !isNaN(n) && n > 0 && n !== currentPid);
                     for (const zPid of zombiePids) {
                         await $`taskkill /F /T /PID ${zPid}`.nothrow().quiet();
                     }
@@ -125,6 +138,11 @@ export async function handleRun(options: CommandOptions) {
     const finalCommand = command || existingProcess!.command;
     const finalDirectory = directory || (existingProcess?.workdir!);
     let finalEnv = env || (existingProcess ? parseEnvString(existingProcess.env) : {});
+    
+    // Default BGR_KEEP_ALIVE=true for new processes unless explicitly disabled
+    if (!('BGR_KEEP_ALIVE' in finalEnv)) {
+        finalEnv.BGR_KEEP_ALIVE = 'true';
+    }
 
     let finalConfigPath: string | undefined | null;
     if (configPath !== undefined) {