bgrun 3.12.1 → 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/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/start/route.ts

@@ -9,12 +9,18 @@ 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: '',
         }));