bgrun 3.12.0 → 3.12.2

package/src/db.ts

@@ -18,10 +18,40 @@ export const ProcessSchema = z.object({
     stdout_path: z.string(),
     stderr_path: z.string(),
     timestamp: z.string().default(() => new Date().toISOString()),
+    group: z.string().default(''),
 });
 
 export type Process = z.infer<typeof ProcessSchema> & { id: number };
 
+export const TemplateSchema = z.object({
+    name: z.string(),
+    command: z.string(),
+    workdir: z.string().default(''),
+    env: z.string().default(''),
+    group: z.string().default(''),
+    created_at: z.string().default(() => new Date().toISOString()),
+});
+
+export type Template = z.infer<typeof TemplateSchema> & { id: number };
+
+export const HistorySchema = z.object({
+    process_name: z.string(),
+    event: z.string(), // 'start', 'stop', 'restart', 'crash', 'guard_on', 'guard_off'
+    pid: z.number().optional(),
+    timestamp: z.string().default(() => new Date().toISOString()),
+    metadata: z.string().default(''), // JSON string for extra info
+});
+
+export type History = z.infer<typeof HistorySchema> & { id: number };
+
+export const DependencySchema = z.object({
+    process_name: z.string(),     // the process that has the dependency
+    depends_on: z.string(),       // the process it depends on
+    created_at: z.string().default(() => new Date().toISOString()),
+});
+
+export type Dependency = z.infer<typeof DependencySchema> & { id: number };
+
 // =============================================================================
 // DATABASE INITIALIZATION
 // =============================================================================
@@ -48,9 +78,15 @@ if (!existsSync(dbPath) && existsSync(legacyDbPath)) {
 
 export const db = new Database(dbPath, {
     process: ProcessSchema,
+    template: TemplateSchema,
+    history: HistorySchema,
+    dependency: DependencySchema,
 }, {
     indexes: {
         process: ['name', 'timestamp', 'pid'],
+        template: ['name'],
+        history: ['process_name', 'timestamp'],
+        dependency: ['process_name', 'depends_on'],
     },
 });
 
@@ -127,6 +163,227 @@ export function updateProcessEnv(name: string, envJson: string) {
     }
 }
 
+// =============================================================================
+// TEMPLATE FUNCTIONS
+// =============================================================================
+
+export function getAllTemplates() {
+    return db.template.select().all();
+}
+
+export function getTemplate(name: string) {
+    return db.template.select().where({ name }).limit(1).get() || null;
+}
+
+export function saveTemplate(data: {
+    name: string;
+    command: string;
+    workdir?: string;
+    env?: string;
+    group?: string;
+}) {
+    const existing = db.template.select().where({ name: data.name }).limit(1).get();
+    if (existing) {
+        db.template.update(existing.id, {
+            command: data.command,
+            workdir: data.workdir || '',
+            env: data.env || '',
+            group: data.group || '',
+        });
+    } else {
+        db.template.insert({
+            name: data.name,
+            command: data.command,
+            workdir: data.workdir || '',
+            env: data.env || '',
+            group: data.group || '',
+        });
+    }
+}
+
+export function deleteTemplate(name: string) {
+    const tmpl = db.template.select().where({ name }).limit(1).get();
+    if (tmpl) {
+        db.template.delete(tmpl.id);
+    }
+}
+
+// =============================================================================
+// HISTORY FUNCTIONS
+// =============================================================================
+
+export function getProcessHistory(name: string, limit = 50) {
+    return db.history.select()
+        .where({ process_name: name })
+        .orderBy('timestamp', 'desc')
+        .limit(limit)
+        .all();
+}
+
+export function addHistoryEntry(processName: string, event: string, pid?: number, metadata = {}) {
+    return db.history.insert({
+        process_name: processName,
+        event,
+        pid,
+        metadata: JSON.stringify(metadata),
+    });
+}
+
+export function getRecentHistory(limit = 100) {
+    return db.history.select()
+        .orderBy('timestamp', 'desc')
+        .limit(limit)
+        .all();
+}
+
+export function clearOldHistory(daysToKeep = 30) {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - daysToKeep);
+    const cutoffStr = cutoff.toISOString();
+    
+    const oldEntries = db.history.select()
+        .where('timestamp', '<', cutoffStr)
+        .all();
+    
+    for (const entry of oldEntries) {
+        db.history.delete(entry.id);
+    }
+    
+    return oldEntries.length;
+}
+
+// =============================================================================
+// DEPENDENCY FUNCTIONS
+// =============================================================================
+
+/** Get all dependencies for a process */
+export function getDependencies(processName: string): string[] {
+    return db.dependency.select()
+        .where({ process_name: processName })
+        .all()
+        .map(d => d.depends_on);
+}
+
+/** Get all processes that depend on a given process */
+export function getDependents(processName: string): string[] {
+    return db.dependency.select()
+        .where({ depends_on: processName })
+        .all()
+        .map(d => d.process_name);
+}
+
+/** Get the full dependency graph: { processName -> [dependsOn...] } */
+export function getDependencyGraph(): Record<string, string[]> {
+    const all = db.dependency.select().all();
+    const graph: Record<string, string[]> = {};
+    for (const dep of all) {
+        if (!graph[dep.process_name]) graph[dep.process_name] = [];
+        graph[dep.process_name].push(dep.depends_on);
+    }
+    return graph;
+}
+
+/** Add a dependency (process_name depends on depends_on) */
+export function addDependency(processName: string, dependsOn: string): boolean {
+    // Prevent self-dependency
+    if (processName === dependsOn) return false;
+    
+    // Prevent duplicates
+    const existing = db.dependency.select()
+        .where({ process_name: processName, depends_on: dependsOn })
+        .limit(1)
+        .get();
+    if (existing) return false;
+    
+    // Prevent circular dependencies
+    if (wouldCreateCycle(processName, dependsOn)) return false;
+    
+    db.dependency.insert({ process_name: processName, depends_on: dependsOn });
+    return true;
+}
+
+/** Remove a dependency */
+export function removeDependency(processName: string, dependsOn: string) {
+    const matches = db.dependency.select()
+        .where({ process_name: processName, depends_on: dependsOn })
+        .all();
+    for (const dep of matches) {
+        db.dependency.delete(dep.id);
+    }
+}
+
+/** Remove all dependencies for a process */
+export function removeAllDependencies(processName: string) {
+    const matches = db.dependency.select()
+        .where({ process_name: processName })
+        .all();
+    for (const dep of matches) {
+        db.dependency.delete(dep.id);
+    }
+}
+
+/** Check if adding processName -> dependsOn would create a cycle */
+function wouldCreateCycle(processName: string, dependsOn: string): boolean {
+    const graph = getDependencyGraph();
+    // Add the proposed edge temporarily
+    if (!graph[processName]) graph[processName] = [];
+    graph[processName].push(dependsOn);
+    
+    // DFS from dependsOn — if we can reach processName, it's a cycle
+    const visited = new Set<string>();
+    const stack = [dependsOn];
+    while (stack.length > 0) {
+        const current = stack.pop()!;
+        if (current === processName) return true;
+        if (visited.has(current)) continue;
+        visited.add(current);
+        for (const dep of (graph[current] || [])) {
+            stack.push(dep);
+        }
+    }
+    return false;
+}
+
+/** Get topological start order (processes with no deps first) */
+export function getStartOrder(): string[] {
+    const graph = getDependencyGraph();
+    const allProcesses = getAllProcesses().map(p => p.name);
+    const allNames = new Set(allProcesses);
+    
+    // Build in-degree map
+    const inDegree: Record<string, number> = {};
+    for (const name of allNames) inDegree[name] = 0;
+    for (const [proc, deps] of Object.entries(graph)) {
+        for (const dep of deps) {
+            if (allNames.has(dep)) {
+                inDegree[proc] = (inDegree[proc] || 0) + 1;
+            }
+        }
+    }
+    
+    // Kahn's algorithm
+    const queue: string[] = [];
+    for (const name of allNames) {
+        if ((inDegree[name] || 0) === 0) queue.push(name);
+    }
+    
+    const order: string[] = [];
+    while (queue.length > 0) {
+        queue.sort(); // stable alphabetical within same level
+        const current = queue.shift()!;
+        order.push(current);
+        // Find processes that depend on current
+        for (const [proc, deps] of Object.entries(graph)) {
+            if (deps.includes(current) && allNames.has(proc)) {
+                inDegree[proc]--;
+                if (inDegree[proc] === 0) queue.push(proc);
+            }
+        }
+    }
+    
+    return order;
+}
+
 // =============================================================================
 // DEBUG / INFO
 // =============================================================================

package/src/deploy.ts

@@ -0,0 +1,163 @@
+import { getProcess, getAllProcesses, addHistoryEntry } from './db';
+import { handleRun } from './commands/run';
+import { $ } from 'bun';
+
+export interface DeployResult {
+    name: string;
+    ok: boolean;
+    skipped?: boolean;
+    reason?: string;
+    pullOutput?: string;
+    installOutput?: string;
+    packageManager?: PackageManager;
+    installCommand?: string;
+    installAttempted?: boolean;
+}
+
+export type PackageManager = 'bun' | 'pnpm' | 'yarn' | 'npm' | null;
+
+export function formatDeployToolError(manager: Exclude<PackageManager, null>, error: unknown): string {
+    const raw = error instanceof Error ? error.message : String(error ?? 'Unknown error');
+    const lower = raw.toLowerCase();
+
+    if (
+        lower.includes('command not found') ||
+        lower.includes('not recognized as an internal or external command') ||
+        lower.includes('executable not found') ||
+        lower.includes('no such file or directory')
+    ) {
+        return `Deploy requires '${manager}', but it is not installed or not available on PATH.`;
+    }
+
+    return `Dependency install failed with ${manager}: ${raw}`;
+}
+
+function isInternalProcess(name: string): boolean {
+    return name === 'bgr-dashboard' || name === 'bgr-guard';
+}
+
+async function pathExists(path: string): Promise<boolean> {
+    return await Bun.file(path).exists();
+}
+
+async function isGitRepo(dir: string): Promise<boolean> {
+    return await pathExists(`${dir}/.git`) || await pathExists(`${dir}/.git/HEAD`);
+}
+
+export async function detectPackageManager(dir: string): Promise<PackageManager> {
+    const hasPackageJson = await pathExists(`${dir}/package.json`);
+    if (!hasPackageJson) return null;
+
+    if (await pathExists(`${dir}/bun.lock`) || await pathExists(`${dir}/bun.lockb`)) return 'bun';
+    if (await pathExists(`${dir}/pnpm-lock.yaml`)) return 'pnpm';
+    if (await pathExists(`${dir}/yarn.lock`)) return 'yarn';
+    if (await pathExists(`${dir}/package-lock.json`) || await pathExists(`${dir}/npm-shrinkwrap.json`)) return 'npm';
+
+    return 'bun';
+}
+
+function getInstallCommand(manager: Exclude<PackageManager, null>): string {
+    switch (manager) {
+        case 'bun': return 'bun install';
+        case 'pnpm': return 'pnpm install --frozen-lockfile';
+        case 'yarn': return 'yarn install --frozen-lockfile';
+        case 'npm': return 'npm ci';
+    }
+}
+
+async function installDependencies(dir: string): Promise<{ manager: PackageManager; output: string; command: string }> {
+    const manager = await detectPackageManager(dir);
+    if (!manager) return { manager: null, output: '', command: '' };
+
+    $.cwd(dir);
+    const command = getInstallCommand(manager);
+
+    try {
+        switch (manager) {
+            case 'bun':
+                return { manager, command, output: (await $`bun install`.text()).trim() };
+            case 'pnpm':
+                return { manager, command, output: (await $`pnpm install --frozen-lockfile`.text()).trim() };
+            case 'yarn':
+                return { manager, command, output: (await $`yarn install --frozen-lockfile`.text()).trim() };
+            case 'npm':
+                return { manager, command, output: (await $`npm ci`.text()).trim() };
+            default:
+                return { manager: null, output: '', command: '' };
+        }
+    } catch (error) {
+        throw new Error(formatDeployToolError(manager, error));
+    }
+}
+
+export async function deployProcess(name: string): Promise<DeployResult> {
+    const proc = getProcess(name);
+    if (!proc) {
+        return { name, ok: false, reason: `Process '${name}' not found` };
+    }
+
+    if (isInternalProcess(proc.name)) {
+        return { name, ok: false, skipped: true, reason: 'Internal bgrun process skipped' };
+    }
+
+    const dir = proc.workdir;
+    if (!(await isGitRepo(dir))) {
+        return { name, ok: false, skipped: true, reason: `'${dir}' is not a git repository` };
+    }
+
+    try {
+        $.cwd(dir);
+
+        const pullOutput = (await $`git pull`.text()).trim();
+
+        const install = await installDependencies(dir);
+        const installOutput = install.output;
+
+        await handleRun({
+            action: 'run',
+            name,
+            force: true,
+            remoteName: '',
+        });
+
+        addHistoryEntry(name, 'deploy', proc.pid, {
+            directory: dir,
+            installed: Boolean(install.manager),
+            packageManager: install.manager,
+            installCommand: install.command,
+        });
+
+        return {
+            name,
+            ok: true,
+            pullOutput,
+            installOutput,
+            packageManager: install.manager,
+            installCommand: install.command,
+            installAttempted: Boolean(install.manager),
+        };
+    } catch (e: any) {
+        return {
+            name,
+            ok: false,
+            reason: e?.message || String(e),
+        };
+    }
+}
+
+export async function deployAllProcesses(group?: string): Promise<DeployResult[]> {
+    const processes = getAllProcesses()
+        .filter(proc => !isInternalProcess(proc.name))
+        .filter(proc => !group || proc.group === group);
+
+    const seen = new Set<string>();
+    const results: DeployResult[] = [];
+
+    for (const proc of processes) {
+        if (seen.has(proc.name)) continue;
+        seen.add(proc.name);
+        results.push(await deployProcess(proc.name));
+    }
+
+    return results;
+}

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] ═══════════════════════════════════════════`);