bgrun 3.11.0 → 3.12.1

package/README.md

@@ -5,6 +5,7 @@
 **Production-ready process manager with dashboard and programmatic API, designed for running your containers, services, and AI agents.**
 
 [![npm](https://img.shields.io/npm/v/bgrun?color=F7A41D&label=npm&logo=npm)](https://www.npmjs.com/package/bgrun)
+[![CI](https://github.com/Mements/bgr/actions/workflows/ci.yml/badge.svg)](https://github.com/Mements/bgr/actions/workflows/ci.yml)
 [![bun](https://img.shields.io/badge/runtime-bun-F7A41D?logo=bun)](https://bun.sh/)
 [![license](https://img.shields.io/npm/l/bgrun)](./LICENSE)
 
@@ -74,11 +75,16 @@ bgrun.yourdomain.com {
 Features:
 - Real-time process status via SSE (no polling)
 - Start, stop, restart, and delete processes from the UI
-- Live stdout/stderr log viewer with search
+- Live stdout/stderr log viewer with search and virtual scrolling
 - Memory, PID, port, runtime, and guard restarts at a glance
 - Guard toggle per-process (auto-restart on crash)
-- Responsive mobile layout
+- Keyboard shortcuts — `↑/↓` or `j/k` navigate, `Enter` open, `R` restart, `S` stop, `G` guard, `D` delete, `N` new, `?` help
+- Search with debounce, result count badge, and persistence across SSE updates
+- Auto-calibrated virtual scroll for large log files (10K+ lines)
+- Dark / light theme toggle
+- Responsive mobile layout with cards view
 - Collapsible directory groups
+- Right-click context menu on process rows
 
 ---
 

package/dashboard/app/api/events/route.ts

@@ -26,7 +26,12 @@ export async function GET(req: Request) {
                 controller.enqueue(encoder.encode(`data: []\n\n`));
             }
 
-            controller.enqueue(encoder.encode(`: keepalive\n\n`));
+            // Periodic keepalive to prevent proxy/browser timeouts
+            const keepaliveInterval = setInterval(() => {
+                try {
+                    controller.enqueue(encoder.encode(`: keepalive\n\n`));
+                } catch { /* stream closed */ }
+            }, 15_000);
 
             // Then send updates every INTERVAL_MS
             const interval = setInterval(async () => {
@@ -40,7 +45,10 @@ export async function GET(req: Request) {
             }, INTERVAL_MS);
 
             // Store cleanup for when the stream is cancelled
-            (stream as any).__cleanup = () => clearInterval(interval);
+            (stream as any).__cleanup = () => {
+                clearInterval(interval);
+                clearInterval(keepaliveInterval);
+            };
         },
         cancel() {
             if ((stream as any).__cleanup) {

package/dashboard/app/api/guard/route.ts

@@ -5,7 +5,7 @@
  * When enabled=true, the built-in guard will auto-restart this process if it dies.
  * When enabled=false, the process is left alone.
  */
-import { getProcess, updateProcessEnv } from '../../../../src/db';
+import { getProcess, updateProcessEnv, addHistoryEntry } from '../../../../src/db';
 
 export async function POST(req: Request) {
     try {
@@ -35,6 +35,9 @@ export async function POST(req: Request) {
         // Save back
         updateProcessEnv(body.name, JSON.stringify(env));
 
+        // Record history
+        addHistoryEntry(body.name, body.enabled ? 'guard_on' : 'guard_off');
+
         return Response.json({
             ok: true,
             name: body.name,

package/dashboard/app/api/guard-events/route.ts

@@ -0,0 +1,5 @@
+import { guardEvents } from '../../../../src/server';
+
+export async function GET() {
+    return Response.json(guardEvents);
+}

package/dashboard/app/api/history/route.ts

@@ -0,0 +1,39 @@
+import { getProcessHistory, getRecentHistory, addHistoryEntry } from '../../../../src/db';
+
+export async function GET(req: Request) {
+    const url = new URL(req.url);
+    const name = url.searchParams.get('name');
+    const limit = parseInt(url.searchParams.get('limit') || '50');
+    
+    let history;
+    if (name) {
+        history = getProcessHistory(name, limit);
+    } else {
+        history = getRecentHistory(limit);
+    }
+    
+    return Response.json(history.map((h: any) => ({
+        process_name: h.process_name,
+        event: h.event,
+        pid: h.pid,
+        timestamp: h.timestamp,
+        metadata: h.metadata ? JSON.parse(h.metadata) : {},
+    })));
+}
+
+export async function POST(req: Request) {
+    try {
+        const body = await req.json();
+        const { process_name, event, pid, metadata } = body;
+        
+        if (!process_name || !event) {
+            return Response.json({ error: 'process_name and event are required' }, { status: 400 });
+        }
+        
+        addHistoryEntry(process_name, event, pid, metadata);
+        return Response.json({ success: true });
+    } catch (err) {
+        console.error('[api/history] Error adding history:', err);
+        return Response.json({ error: 'Failed to add history' }, { status: 500 });
+    }
+}

package/dashboard/app/api/processes/route.ts

@@ -237,10 +237,11 @@ async function fetchProcesses(): Promise<any[]> {
 export async function GET(req: Request) {
     const url = new URL(req.url);
     const bustCache = url.searchParams.has('t');
+    const portFilter = url.searchParams.get('port');
     const now = Date.now();
 
-    // Return cached data if still fresh and no bust param
-    if (!bustCache && cache.data && (now - cache.timestamp) < CACHE_TTL_MS) {
+    // Return cached data if still fresh and no bust param and no port filter
+    if (!bustCache && !portFilter && cache.data && (now - cache.timestamp) < CACHE_TTL_MS) {
         return Response.json(cache.data);
     }
 
@@ -258,7 +259,14 @@ export async function GET(req: Request) {
     }
 
     try {
-        const result = await cache.inflight;
+        let result = await cache.inflight;
+        // Filter by port if specified (also ensures fresh data by bypassing cache above)
+        if (portFilter) {
+            const portNum = parseInt(portFilter);
+            if (!isNaN(portNum)) {
+                result = result.filter((p: any) => p.ports?.includes(portNum));
+            }
+        }
         return Response.json(result);
     } catch (err) {
         console.error('[api/processes] Error fetching processes:', err);

package/dashboard/app/api/restart/[name]/route.ts

@@ -2,10 +2,13 @@
  * POST /api/restart/:name — Force-restart a process
  */
 import { handleRun } from '../../../../../src/commands/run';
+import { addHistoryEntry, getProcess } from '../../../../../src/db';
 import { measure } from 'measure-fn';
 
 export async function POST(req: Request, { params }: { params: { name: string } }) {
     const name = decodeURIComponent(params.name);
+    const proc = getProcess(name);
+    const oldPid = proc?.pid;
 
     try {
         await measure(`Restart "${name}"`, () => handleRun({
@@ -14,6 +17,10 @@ export async function POST(req: Request, { params }: { params: { name: string }
             force: true,
             remoteName: '',
         }));
+        
+        // Record history
+        addHistoryEntry(name, 'restart', oldPid);
+        
         return Response.json({ success: true });
     } catch (e: any) {
         return Response.json({ error: e.message }, { status: 500 });

package/dashboard/app/api/start/route.ts

@@ -2,6 +2,7 @@
  * POST /api/start — Create or start a process
  */
 import { handleRun } from '../../../../src/commands/run';
+import { addHistoryEntry } from '../../../../src/db';
 import { measure } from 'measure-fn';
 
 export async function POST(req: Request) {
@@ -16,6 +17,10 @@ export async function POST(req: Request) {
             force: body.force || false,
             remoteName: '',
         }));
+        
+        // Record history
+        addHistoryEntry(body.name, 'start');
+        
         return Response.json({ success: true });
     } catch (e: any) {
         return Response.json({ error: e.message }, { status: 500 });

package/dashboard/app/api/stop/[name]/route.ts

@@ -4,7 +4,7 @@
  * Kills the registered PID, then kills anything remaining on the port.
  * Sets PID to 0 to prevent reconciliation from hijacking unrelated processes.
  */
-import { getProcess, updateProcessPid } from '../../../../../src/db';
+import { getProcess, updateProcessPid, addHistoryEntry } from '../../../../../src/db';
 import { isProcessRunning, terminateProcess, getProcessPorts, killProcessOnPort } from '../../../../../src/platform';
 import { measure } from 'measure-fn';
 
@@ -37,5 +37,8 @@ export async function POST(req: Request, { params }: { params: { name: string }
     // a random matching process as this one
     updateProcessPid(name, 0);
 
+    // Record history
+    addHistoryEntry(name, 'stop', proc.pid);
+
     return Response.json({ success: true });
 }

package/dashboard/app/api/templates/route.ts

@@ -0,0 +1,47 @@
+import { getAllTemplates, saveTemplate, deleteTemplate } from '../../../../src/db';
+
+export async function GET() {
+    const templates = getAllTemplates();
+    return Response.json(templates.map((t: any) => ({
+        name: t.name,
+        command: t.command,
+        workdir: t.workdir,
+        env: t.env,
+        group: t.group,
+        created_at: t.created_at,
+    })));
+}
+
+export async function POST(req: Request) {
+    try {
+        const body = await req.json();
+        const { name, command, workdir, env, group } = body;
+        
+        if (!name || !command) {
+            return Response.json({ error: 'name and command are required' }, { status: 400 });
+        }
+        
+        saveTemplate({ name, command, workdir, env, group });
+        return Response.json({ success: true, name });
+    } catch (err) {
+        console.error('[api/templates] Error saving template:', err);
+        return Response.json({ error: 'Failed to save template' }, { status: 500 });
+    }
+}
+
+export async function DELETE(req: Request) {
+    try {
+        const url = new URL(req.url);
+        const name = url.searchParams.get('name');
+        
+        if (!name) {
+            return Response.json({ error: 'name is required' }, { status: 400 });
+        }
+        
+        deleteTemplate(name);
+        return Response.json({ success: true });
+    } catch (err) {
+        console.error('[api/templates] Error deleting template:', err);
+        return Response.json({ error: 'Failed to delete template' }, { status: 500 });
+    }
+}