bgrun 3.11.0 → 3.12.1

package/src/guard.ts

@@ -18,6 +18,11 @@ import { getAllProcesses, getProcess } from './db';
 import { isProcessRunning, getProcessPorts, findChildPid } from './platform';
 import { handleRun } from './commands/run';
 import { parseEnvString } from './utils';
+import { createHmac } from 'crypto';
+
+// Webhook configuration via environment variables
+const WEBHOOK_URL = process.env.BGR_WEBHOOK_URL || '';
+const WEBHOOK_SECRET = process.env.BGR_WEBHOOK_SECRET || '';
 
 const DEFAULT_INTERVAL_MS = 30_000;
 const MAX_BACKOFF_MS = 5 * 60_000; // 5 minutes max
@@ -36,6 +41,42 @@ const state: GuardState = {
     lastSeenAlive: new Map(),
 };
 
+async function notifyWebhook(event: 'crash' | 'restart' | 'restart_failed', name: string, details: Record<string, any>) {
+    if (!WEBHOOK_URL) return;
+    try {
+        const payload = JSON.stringify({
+            event,
+            process: name,
+            timestamp: new Date().toISOString(),
+            ...details,
+        });
+
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json',
+            'User-Agent': 'bgrun-guard/1.0',
+        };
+
+        // HMAC signature if secret is configured
+        if (WEBHOOK_SECRET) {
+            const sig = createHmac('sha256', WEBHOOK_SECRET).update(payload).digest('hex');
+            headers['X-BGR-Signature'] = `sha256=${sig}`;
+        }
+
+        // Fire and forget with timeout
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        await fetch(WEBHOOK_URL, {
+            method: 'POST',
+            headers,
+            body: payload,
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+    } catch (err: any) {
+        console.error(`[guard] Webhook failed: ${err.message}`);
+    }
+}
+
 async function restartProcess(name: string): Promise<boolean> {
     try {
         await handleRun({
@@ -94,6 +135,9 @@ async function guardCycle(): Promise<void> {
 
                     console.log(`[guard] ⚠ "${proc.name}" (PID ${proc.pid}) is dead — restarting...`);
 
+                    // Notify crash detected
+                    notifyWebhook('crash', proc.name, { pid: proc.pid, isDashboard });
+
                     const success = await restartProcess(proc.name);
                     if (success) {
                         const count = (state.restartCounts.get(proc.name) || 0) + 1;
@@ -108,6 +152,12 @@ async function guardCycle(): Promise<void> {
                             console.log(`[guard] ✓ Restarted "${proc.name}" (#${count})`);
                         }
                         restarted++;
+
+                        // Notify restart success
+                        notifyWebhook('restart', proc.name, { pid: proc.pid, restartCount: count, backoffMs: backoff });
+                    } else {
+                        // Notify restart failed
+                        notifyWebhook('restart_failed', proc.name, { pid: proc.pid });
                     }
                 } else if (alive) {
                     // Track stability — if alive for STABILITY_WINDOW, reset counters
@@ -146,6 +196,7 @@ export async function startGuardLoop(intervalMs: number = DEFAULT_INTERVAL_MS) {
     console.log(`[guard]    Crash backoff threshold: ${CRASH_THRESHOLD} restarts`);
     console.log(`[guard]    Stability window: ${STABILITY_WINDOW_MS / 1000}s`);
     console.log(`[guard]    Monitoring: BGR_KEEP_ALIVE=true + bgr-dashboard`);
+    console.log(`[guard]    Webhook: ${WEBHOOK_URL || '(none — set BGR_WEBHOOK_URL to enable)'}`);
     console.log(`[guard]    Started: ${new Date().toLocaleString()}`);
     console.log(`[guard] ═══════════════════════════════════════════`);
 

package/src/index.ts

@@ -12,7 +12,7 @@ import type { CommandOptions } from "./types";
 import { error, announce } from "./logger";
 // startServer is dynamically imported only when --_serve is used
 // to avoid loading melina (which has side-effects) on every bgrun command
-import { getHomeDir, getShellCommand, findChildPid, isProcessRunning, terminateProcess, getProcessPorts, killProcessOnPort, waitForPortFree, isPortFree } from "./platform";
+import { getHomeDir, getShellCommand, findChildPid, isProcessRunning, terminateProcess, getProcessPorts, killProcessOnPort, waitForPortFree, isPortFree, findPidByPort } from "./platform";
 import { insertProcess, removeProcessByName, getProcess, retryDatabaseOperation, getDbInfo } from "./db";
 import dedent from "dedent";
 import chalk from "chalk";
@@ -26,6 +26,48 @@ if (!Bun.argv.includes("--_serve")) {
   }
 }
 
+/**
+ * Redirect console.log/warn/error to log files when running detached.
+ * The parent spawner passes file paths via BGR_STDOUT/BGR_STDERR env vars.
+ * Appends timestamped lines so `bgrun <name> --logs` shows real output.
+ */
+function redirectConsoleToFiles() {
+  const stdoutPath = Bun.env.BGR_STDOUT;
+  const stderrPath = Bun.env.BGR_STDERR;
+  if (!stdoutPath && !stderrPath) return; // Not detached, keep normal console
+
+  const { appendFileSync } = require('fs');
+
+  // Strip ANSI escape codes for clean log files
+  const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, '');
+
+  const timestamp = () => new Date().toISOString().replace('T', ' ').substring(0, 19);
+
+  if (stdoutPath) {
+    const origLog = console.log;
+    const origWarn = console.warn;
+    console.log = (...args: any[]) => {
+      const line = `[${timestamp()}] ${stripAnsi(args.map(String).join(' '))}\n`;
+      try { appendFileSync(stdoutPath, line); } catch { }
+      origLog.apply(console, args); // Also keep original (goes to /dev/null when detached, but useful if attached)
+    };
+    console.warn = (...args: any[]) => {
+      const line = `[${timestamp()}] WARN: ${stripAnsi(args.map(String).join(' '))}\n`;
+      try { appendFileSync(stdoutPath, line); } catch { }
+      origWarn.apply(console, args);
+    };
+  }
+
+  if (stderrPath) {
+    const origError = console.error;
+    console.error = (...args: any[]) => {
+      const line = `[${timestamp()}] ERROR: ${stripAnsi(args.map(String).join(' '))}\n`;
+      try { appendFileSync(stderrPath, line); } catch { }
+      origError.apply(console, args);
+    };
+  }
+}
+
 async function showHelp() {
   const usage = dedent`
     ${chalk.bold('bgrun — Bun Background Runner')}
@@ -120,6 +162,9 @@ async function run() {
   // Port is NOT passed explicitly — Melina auto-detects from BUN_PORT env
   // or defaults to 3000 with fallback to next available port.
   if (values['_serve']) {
+    // Redirect console output to log files when running detached
+    // The spawner passes paths via BGR_STDOUT/BGR_STDERR env vars
+    redirectConsoleToFiles();
     const { startServer } = await import("./server");
     await startServer();
     return;
@@ -127,6 +172,8 @@ async function run() {
 
   // Internal: actually run the guard loop (spawned by --guard)
   if (values['_guard-loop']) {
+    // Redirect console output to log files when running detached
+    redirectConsoleToFiles();
     const { startGuardLoop } = await import("./guard");
     const intervalStr = positionals[0];
     const intervalMs = intervalStr ? parseInt(intervalStr) * 1000 : undefined;
@@ -193,10 +240,13 @@ async function run() {
     await Bun.write(stderrPath, '');
 
     // Pass BUN_PORT env var only if user explicitly requested a port
-    const spawnEnv = { ...Bun.env };
+    const spawnEnv: Record<string, string> = { ...Bun.env } as any;
     if (requestedPort) {
       spawnEnv.BUN_PORT = requestedPort;
     }
+    // Pass log paths so the detached process can redirect its own console output
+    spawnEnv.BGR_STDOUT = stdoutPath;
+    spawnEnv.BGR_STDERR = stderrPath;
 
     // Resolve the target port: --port flag > BUN_PORT env > default 3000
     const targetPort = parseInt(requestedPort || Bun.env.BUN_PORT || '3000');
@@ -216,16 +266,18 @@ async function run() {
     const newProcess = Bun.spawn(getShellCommand(spawnCommand), {
       env: spawnEnv,
       cwd: bgrDir,
-      stdout: Bun.file(stdoutPath),
-      stderr: Bun.file(stderrPath),
-    });
+      stdout: "ignore",
+      stderr: "ignore",
+      detached: true, // Windows: new process group outside parent's Job Object — survives terminal close
+    } as any);
 
     newProcess.unref();
 
-    // Resolve the actual child PID by traversing the process tree
-    // (cmd.exe → bun.exe), then detect which port it bound
+    // With detached: cmd.exe wrapper exits immediately, so findChildPid won't work.
+    // Instead, wait for the server to bind a port and find the PID from there.
     await sleep(2000); // Give the server time to start and bind a port
-    const actualPid = await findChildPid(newProcess.pid);
+    const resolvedPort = parseInt(requestedPort || Bun.env.BUN_PORT || '3000');
+    const actualPid = await findPidByPort(resolvedPort, 10000) ?? await findChildPid(newProcess.pid);
 
     // Detect the port the server actually bound to
     let actualPort: number | null = null;
@@ -310,15 +362,27 @@ async function run() {
     await Bun.write(stderrPath, '');
 
     const newProcess = Bun.spawn(getShellCommand(spawnCommand), {
-      env: { ...Bun.env },
+      env: { ...Bun.env, BGR_STDOUT: stdoutPath, BGR_STDERR: stderrPath },
       cwd: bgrDir,
-      stdout: Bun.file(stdoutPath),
-      stderr: Bun.file(stderrPath),
-    });
+      stdout: "ignore",
+      stderr: "ignore",
+      detached: true, // Windows: new process group outside parent's Job Object — survives terminal close
+    } as any);
 
     newProcess.unref();
     await sleep(1000);
-    const actualPid = await findChildPid(newProcess.pid);
+    // With detached: cmd.exe exits immediately. Search for the guard by command line.
+    let actualPid = await findChildPid(newProcess.pid);
+    if (!(await isProcessRunning(actualPid))) {
+      // cmd.exe already died — search for the bun process running --_guard-loop
+      const { psExec: ps } = await import('./platform');
+      const result = ps(
+        `Get-CimInstance Win32_Process -Filter "Name='bun.exe'" | Where-Object { $_.CommandLine -match '_guard-loop' } | Sort-Object -Property CreationDate -Descending | Select-Object -First 1 -ExpandProperty ProcessId`,
+        3000
+      );
+      const foundPid = parseInt(result.trim());
+      if (!isNaN(foundPid) && foundPid > 0) actualPid = foundPid;
+    }
 
     await retryDatabaseOperation(() =>
       insertProcess({
@@ -541,5 +605,10 @@ async function run() {
 }
 
 run().catch(err => {
-  error(err);
+  // BgrunError was already printed by error() — just exit
+  // For unexpected errors, print and exit
+  if (err.name !== 'BgrunError') {
+    console.error(err);
+  }
+  process.exit(1);
 });