bgrun 3.12.0 → 3.12.2

package/dashboard/app/api/check-port/route.ts

@@ -0,0 +1,35 @@
+/**
+ * GET /api/check-port?port=3001 — Check if a port is in use
+ * 
+ * Attempts a TCP connect to localhost:port. Returns { inUse, port }.
+ */
+
+export async function GET(req: Request) {
+    const url = new URL(req.url);
+    const port = parseInt(url.searchParams.get('port') || '0');
+
+    if (!port || port < 1 || port > 65535) {
+        return Response.json({ error: 'Invalid port' }, { status: 400 });
+    }
+
+    const inUse = await isPortInUse(port);
+    return Response.json({ port, inUse });
+}
+
+async function isPortInUse(port: number): Promise<boolean> {
+    return new Promise((resolve) => {
+        try {
+            const server = Bun.serve({
+                port,
+                hostname: '127.0.0.1',
+                fetch() { return new Response(''); },
+            });
+            // If we successfully bound, it's free
+            server.stop(true);
+            resolve(false);
+        } catch {
+            // Port is in use
+            resolve(true);
+        }
+    });
+}

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

@@ -0,0 +1,40 @@
+import { getDependencyGraph, addDependency, removeDependency, getStartOrder, getAllProcesses } from "../../../../src/db";
+
+/** GET /api/dependencies — full dependency graph + start order */
+export function GET() {
+    const graph = getDependencyGraph();
+    const startOrder = getStartOrder();
+    const processes = getAllProcesses().map(p => ({
+        name: p.name,
+        group: p.group || '',
+        pid: p.pid,
+    }));
+
+    return Response.json({ graph, startOrder, processes });
+}
+
+/** POST /api/dependencies — add a dependency */
+export async function POST(req: Request) {
+    const body = await req.json() as { process: string; depends_on: string };
+    if (!body.process || !body.depends_on) {
+        return Response.json({ error: 'Missing process or depends_on' }, { status: 400 });
+    }
+
+    const ok = addDependency(body.process, body.depends_on);
+    if (!ok) {
+        return Response.json({ error: 'Invalid dependency (duplicate, self-reference, or would create cycle)' }, { status: 400 });
+    }
+
+    return Response.json({ ok: true });
+}
+
+/** DELETE /api/dependencies — remove a dependency */
+export async function DELETE(req: Request) {
+    const body = await req.json() as { process: string; depends_on: string };
+    if (!body.process || !body.depends_on) {
+        return Response.json({ error: 'Missing process or depends_on' }, { status: 400 });
+    }
+
+    removeDependency(body.process, body.depends_on);
+    return Response.json({ ok: true });
+}

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

@@ -4,54 +4,19 @@
  * Only works if the process directory is a git repository.
  * Steps: git pull → bun install → force restart
  */
-import { getProcess } from '../../../../../src/db';
-import { handleRun } from '../../../../../src/commands/run';
-import { measure } from 'measure-fn';
-import { $ } from 'bun';
+import { deployProcess } from '../../../../../src/deploy';
 
 export async function POST(req: Request, { params }: { params: { name: string } }) {
     const name = decodeURIComponent(params.name);
 
     try {
-        const proc = getProcess(name);
-        if (!proc) {
-            return Response.json({ error: `Process '${name}' not found` }, { status: 404 });
+        const result = await deployProcess(name);
+        if (result.ok) {
+            return Response.json({ success: true, ...result });
         }
 
-        const dir = proc.workdir;
-
-        // Check if it's a git repo
-        const isGit = await Bun.file(`${dir}/.git/HEAD`).exists();
-        if (!isGit) {
-            return Response.json({ error: `'${dir}' is not a git repository` }, { status: 400 });
-        }
-
-        const result = await measure(`Deploy "${name}"`, async () => {
-            // 1. Git pull
-            $.cwd(dir);
-            const pullOutput = await $`git pull`.text();
-
-            // 2. Install dependencies (detect package manager)
-            let installOutput = '';
-            const hasBunLock = await Bun.file(`${dir}/bun.lock`).exists() || await Bun.file(`${dir}/bun.lockb`).exists();
-            const hasPackageJson = await Bun.file(`${dir}/package.json`).exists();
-
-            if (hasPackageJson) {
-                installOutput = await $`bun install`.text();
-            }
-
-            // 3. Restart the process
-            await handleRun({
-                action: 'run',
-                name,
-                force: true,
-                remoteName: '',
-            });
-
-            return { pullOutput: pullOutput.trim(), installOutput: installOutput.trim() };
-        });
-
-        return Response.json({ success: true, ...result });
+        const status = result.skipped ? 400 : 500;
+        return Response.json({ error: result.reason || `Failed to deploy '${name}'`, ...result }, { status });
     } catch (e: any) {
         return Response.json({ error: e.message }, { status: 500 });
     }

package/dashboard/app/api/deploy-all/route.ts

@@ -0,0 +1,25 @@
+import { deployAllProcesses } from '../../../../src/deploy';
+
+export async function POST(req: Request) {
+    try {
+        const body = await req.json().catch(() => ({}));
+        const group = body?.group ? String(body.group) : undefined;
+        const results = await deployAllProcesses(group);
+
+        const deployed = results.filter(r => r.ok);
+        const skipped = results.filter(r => r.skipped);
+        const failed = results.filter(r => !r.ok && !r.skipped);
+
+        return Response.json({
+            success: failed.length === 0,
+            group: group || null,
+            total: results.length,
+            deployed: deployed.length,
+            skipped: skipped.length,
+            failed: failed.length,
+            results,
+        }, { status: failed.length > 0 ? 207 : 200 });
+    } catch (e: any) {
+        return Response.json({ error: e?.message || String(e) }, { status: 500 });
+    }
+}

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/next-port/route.ts

@@ -0,0 +1,32 @@
+/**
+ * GET /api/next-port — Find the next available port
+ * 
+ * Scans existing processes' env for PORT= values,
+ * then returns the next unused port starting from a base (default 3001).
+ */
+import { getAllProcesses } from '../../../../src/db';
+
+export async function GET(req: Request) {
+    const url = new URL(req.url);
+    const base = parseInt(url.searchParams.get('base') || '3001') || 3001;
+
+    const processes = getAllProcesses();
+    const usedPorts = new Set<number>();
+
+    for (const proc of processes) {
+        // Parse PORT from env string (comma-separated KEY=VAL)
+        const envStr = proc.env || '';
+        const portMatch = envStr.match(/(?:^|,)PORT=(\d+)/);
+        if (portMatch) {
+            usedPorts.add(parseInt(portMatch[1]));
+        }
+    }
+
+    // Find next available port
+    let nextPort = base;
+    while (usedPorts.has(nextPort)) {
+        nextPort++;
+    }
+
+    return Response.json({ port: nextPort, usedPorts: Array.from(usedPorts).sort((a, b) => a - b) });
+}

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,20 +2,31 @@
  * 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) {
     const body = await req.json();
 
     try {
+        // Build env from body.env object if provided (e.g. { PORT: "3001" })
+        const env = body.env && typeof body.env === 'object'
+            ? body.env as Record<string, string>
+            : undefined;
+
         await measure(`Start process "${body.name}"`, () => handleRun({
             action: 'run',
             name: body.name,
             command: body.command,
             directory: body.directory,
             force: body.force || false,
+            env,
             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 });
+    }
+}