bgrun 3.12.10 → 3.12.12

package/dist/server.js

@@ -0,0 +1,1488 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/platform.ts
+var exports_platform = {};
+__export(exports_platform, {
+  waitForPortFree: () => waitForPortFree,
+  terminateProcess: () => terminateProcess,
+  reconcileProcessPids: () => reconcileProcessPids,
+  readFileTail: () => readFileTail,
+  psExec: () => psExec,
+  parseUnixListeningPorts: () => parseUnixListeningPorts,
+  killProcessOnPort: () => killProcessOnPort,
+  isWindows: () => isWindows,
+  isProcessRunning: () => isProcessRunning,
+  isPortFree: () => isPortFree,
+  getShellCommand: () => getShellCommand,
+  getProcessPorts: () => getProcessPorts,
+  getProcessMemory: () => getProcessMemory,
+  getProcessBatchResources: () => getProcessBatchResources,
+  getPortInfo: () => getPortInfo,
+  getHomeDir: () => getHomeDir,
+  findPidByPort: () => findPidByPort,
+  findChildPid: () => findChildPid,
+  ensureDir: () => ensureDir,
+  copyFile: () => copyFile
+});
+import * as fs from "fs";
+import * as os from "os";
+import { join } from "path";
+var {$ } = globalThis.Bun;
+import { createMeasure } from "measure-fn";
+function psExec(command, _timeoutMs = 3000) {
+  const tmpFile = join(os.tmpdir(), `bgr-ps-${Date.now()}.ps1`);
+  try {
+    fs.writeFileSync(tmpFile, command);
+    const result = Bun.spawnSync(["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", tmpFile]);
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch {}
+    return result.stdout?.toString() || "";
+  } catch {
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch {}
+    return "";
+  }
+}
+function isWindows() {
+  return process.platform === "win32";
+}
+function getHomeDir() {
+  return os.homedir();
+}
+async function isProcessRunning(pid, command) {
+  if (pid <= 0)
+    return false;
+  return await plat.measure(`PID ${pid} alive?`, async () => {
+    try {
+      if (command && (command.includes("docker run") || command.includes("docker-compose up") || command.includes("docker compose up"))) {
+        return await isDockerContainerRunning(command);
+      }
+      if (isWindows()) {
+        try {
+          process.kill(pid, 0);
+          return true;
+        } catch {
+          const output = psExec(`Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id`).trim();
+          return output === String(pid);
+        }
+      } else {
+        const result = await $`ps -p ${pid}`.nothrow().text();
+        return result.includes(`${pid}`);
+      }
+    } catch {
+      return false;
+    }
+  }) ?? false;
+}
+async function isDockerContainerRunning(command) {
+  try {
+    const nameMatch = command.match(/--name\s+["']?(\S+?)["']?(?:\s|$)/);
+    if (nameMatch) {
+      const containerName = nameMatch[1];
+      const result = await $`docker inspect -f "{{.State.Running}}" ${containerName}`.nothrow().text();
+      return result.trim() === "true";
+    }
+    const imageMatch = command.match(/docker\s+run\s+.*?(?:-d\s+)?(\S+)\s*$/);
+    if (imageMatch) {
+      const imageName = imageMatch[1];
+      const result = await $`docker ps --filter ancestor=${imageName} --format "{{.ID}}"`.nothrow().text();
+      return result.trim().length > 0;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function getChildPids(pid) {
+  try {
+    if (isWindows()) {
+      const result = await psExec(`Get-CimInstance Win32_Process -Filter 'ParentProcessId=${pid}' | Select-Object -ExpandProperty ProcessId`, 3000);
+      return result.split(`
+`).map((line) => parseInt(line.trim())).filter((n) => !isNaN(n) && n > 0);
+    } else {
+      const result = await $`ps --no-headers -o pid --ppid ${pid}`.nothrow().text();
+      return result.trim().split(`
+`).filter((p) => p.trim()).map((p) => parseInt(p)).filter((n) => !isNaN(n));
+    }
+  } catch {
+    return [];
+  }
+}
+async function terminateProcess(pid, force = false) {
+  await plat.measure(`Terminate PID ${pid}`, async (m) => {
+    try {
+      if (isWindows()) {
+        await $`taskkill /F /T /PID ${pid}`.nothrow().quiet();
+      } else {
+        const children = await m("Get children", () => getChildPids(pid)) ?? [];
+        const signal = force ? "KILL" : "TERM";
+        for (const childPid of children) {
+          try {
+            await $`kill -${signal} ${childPid}`.nothrow();
+          } catch {}
+        }
+        await Bun.sleep(500);
+        if (await isProcessRunning(pid)) {
+          await $`kill -${signal} ${pid}`.nothrow();
+        }
+      }
+    } catch {}
+    await Bun.sleep(300);
+  });
+}
+async function isPortFree(port) {
+  try {
+    if (isWindows()) {
+      const result = await $`netstat -ano | findstr :${port}`.nothrow().quiet().text();
+      for (const line of result.split(`
+`)) {
+        const match = line.match(new RegExp(`:(${port})\\s+.*LISTENING\\s+(\\d+)`));
+        if (match) {
+          const pid = parseInt(match[2]);
+          if (pid > 0 && await isProcessRunning(pid)) {
+            return false;
+          }
+        }
+      }
+      return true;
+    } else {
+      const result = await $`ss -tln sport = :${port}`.nothrow().quiet().text();
+      const lines = result.trim().split(`
+`).filter((l) => l.trim());
+      return lines.length <= 1;
+    }
+  } catch {
+    return true;
+  }
+}
+async function getPortInfo(port) {
+  try {
+    if (isWindows()) {
+      const result = await $`netstat -ano | findstr :${port}`.nothrow().quiet().text();
+      for (const line of result.split(`
+`)) {
+        const match = line.match(new RegExp(`:(${port})\\s+.*LISTENING\\s+(\\d+)`));
+        if (match) {
+          const pid = parseInt(match[2]);
+          if (pid > 0 && await isProcessRunning(pid)) {
+            const nameResult = await $`powershell -NoProfile -Command "(Get-Process -Id ${pid} -ErrorAction SilentlyContinue).ProcessName"`.nothrow().quiet().text();
+            return { inUse: true, pid, processName: nameResult.trim() || "unknown" };
+          }
+        }
+      }
+      return { inUse: false };
+    } else {
+      const result = await $`ss -tln sport = :${port}`.nothrow().quiet().text();
+      const lines = result.trim().split(`
+`).filter((l) => l.trim());
+      if (lines.length > 1) {
+        return { inUse: true };
+      }
+      return { inUse: false };
+    }
+  } catch {
+    return { inUse: false };
+  }
+}
+async function waitForPortFree(port, timeoutMs = 5000) {
+  const startTime = Date.now();
+  const pollInterval = 300;
+  while (Date.now() - startTime < timeoutMs) {
+    if (await isPortFree(port)) {
+      return true;
+    }
+    await Bun.sleep(pollInterval);
+  }
+  return false;
+}
+async function killProcessOnPort(port) {
+  try {
+    if (isWindows()) {
+      const result = await $`netstat -ano | findstr :${port}`.nothrow().quiet().text();
+      const pids = new Set;
+      for (const line of result.split(`
+`)) {
+        const match = line.match(new RegExp(`:(${port})\\s+.*?\\s+(\\d+)\\s*$`));
+        if (match && parseInt(match[1]) === port) {
+          const pid = parseInt(match[2]);
+          if (pid > 0)
+            pids.add(pid);
+        }
+      }
+      for (const pid of pids) {
+        const alive = await isProcessRunning(pid);
+        if (alive) {
+          await $`taskkill /F /T /PID ${pid}`.nothrow().quiet();
+          console.log(`Killed process ${pid} using port ${port}`);
+        } else {
+          console.warn(`\u26A0 Port ${port} held by zombie PID ${pid} (process dead, socket stuck in kernel). Will clear on reboot or TCP timeout.`);
+        }
+      }
+    } else {
+      const result = await $`lsof -ti :${port}`.nothrow().text();
+      if (result.trim()) {
+        const pids = result.trim().split(`
+`).filter((pid) => pid);
+        for (const pid of pids) {
+          await $`kill -9 ${pid}`.nothrow();
+          console.log(`Killed process ${pid} using port ${port}`);
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not check or kill process on port ${port}: ${error}`);
+  }
+}
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function getShellCommand(command) {
+  if (isWindows()) {
+    return ["cmd", "/c", command];
+  } else {
+    return ["sh", "-c", command];
+  }
+}
+async function findChildPid(parentPid) {
+  let currentPid = parentPid;
+  const maxDepth = 2;
+  for (let depth = 0;depth < maxDepth; depth++) {
+    try {
+      let childPids = [];
+      if (isWindows()) {
+        const result = await psExec(`Get-CimInstance Win32_Process -Filter 'ParentProcessId=${currentPid}' | Select-Object -ExpandProperty ProcessId`, 3000);
+        childPids = result.split(`
+`).map((line) => parseInt(line.trim())).filter((n) => !isNaN(n) && n > 0);
+      } else {
+        const result = await $`ps --no-headers -o pid --ppid ${currentPid}`.nothrow().text();
+        childPids = result.trim().split(`
+`).map((line) => parseInt(line.trim())).filter((n) => !isNaN(n) && n > 0);
+      }
+      if (childPids.length === 0)
+        break;
+      currentPid = childPids[0];
+    } catch {
+      break;
+    }
+  }
+  return currentPid;
+}
+async function reconcileProcessPids(processes, deadPids) {
+  return await plat.measure("Reconcile PIDs", async () => {
+    const result = new Map;
+    const needsReconciliation = processes.filter((p) => deadPids.has(p.pid) && p.pid > 0);
+    if (needsReconciliation.length === 0)
+      return result;
+    try {
+      let runningProcs = [];
+      if (isWindows()) {
+        const output = await psExec(`Get-CimInstance Win32_Process -Filter "Name='bun.exe'" | ForEach-Object { Write-Output "$($_.ProcessId)|$($_.CommandLine)" }`, 5000);
+        for (const line of output.split(`
+`)) {
+          const sepIdx = line.indexOf("|");
+          if (sepIdx === -1)
+            continue;
+          const pid = parseInt(line.substring(0, sepIdx).trim());
+          const cmdLine = line.substring(sepIdx + 1).trim();
+          if (!isNaN(pid) && pid > 0 && cmdLine) {
+            runningProcs.push({ pid, cmdLine });
+          }
+        }
+      } else {
+        const psOutput = await $`ps -eo pid,args --no-headers`.nothrow().quiet().text();
+        for (const line of psOutput.trim().split(`
+`)) {
+          const match = line.trim().match(/^(\d+)\s+(.+)/);
+          if (match) {
+            runningProcs.push({ pid: parseInt(match[1]), cmdLine: match[2] });
+          }
+        }
+      }
+      for (const proc of needsReconciliation) {
+        const cmdParts = proc.command.split(/\s+/);
+        const workdirParts = proc.workdir.replace(/\\/g, "/").split("/").filter(Boolean);
+        const workdirLast = workdirParts[workdirParts.length - 1]?.toLowerCase() || "";
+        let bestMatch = null;
+        let ambiguous = false;
+        for (const running of runningProcs) {
+          const cmdLower = running.cmdLine.toLowerCase();
+          let score = 0;
+          for (const part of cmdParts) {
+            if (part.length > 2 && cmdLower.includes(part.toLowerCase()))
+              score++;
+          }
+          if (workdirLast && cmdLower.includes(workdirLast))
+            score += 3;
+          if (cmdLower.includes(proc.workdir.toLowerCase().replace(/\\/g, "/")))
+            score += 5;
+          if (cmdLower.includes(proc.workdir.toLowerCase()))
+            score += 5;
+          if (score < 4)
+            continue;
+          if (!bestMatch || score > bestMatch.score) {
+            ambiguous = false;
+            bestMatch = { pid: running.pid, score };
+          } else if (score === bestMatch.score) {
+            ambiguous = true;
+          }
+        }
+        if (bestMatch && !ambiguous) {
+          result.set(proc.name, bestMatch.pid);
+          runningProcs = runningProcs.filter((p) => p.pid !== bestMatch.pid);
+        }
+      }
+    } catch {}
+    return result;
+  }) ?? new Map;
+}
+async function findPidByPort(port, maxWaitMs = 8000) {
+  const start = Date.now();
+  const pollMs = 500;
+  while (Date.now() - start < maxWaitMs) {
+    try {
+      if (isWindows()) {
+        const result = await $`netstat -ano`.nothrow().quiet().text();
+        for (const line of result.split(`
+`)) {
+          if (line.includes(`:${port}`) && line.includes("LISTENING")) {
+            const parts = line.trim().split(/\s+/);
+            const pid = parseInt(parts[parts.length - 1]);
+            if (!isNaN(pid) && pid > 0)
+              return pid;
+          }
+        }
+      } else {
+        try {
+          const result2 = await $`ss -tlnp`.nothrow().quiet().text();
+          for (const line of result2.split(`
+`)) {
+            if (line.includes(`:${port}`)) {
+              const pidMatch = line.match(/pid=(\d+)/);
+              if (pidMatch)
+                return parseInt(pidMatch[1]);
+            }
+          }
+        } catch {}
+        const result = await $`lsof -iTCP:${port} -sTCP:LISTEN -t`.nothrow().quiet().text();
+        const pid = parseInt(result.trim());
+        if (!isNaN(pid) && pid > 0)
+          return pid;
+      }
+    } catch {}
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+  return null;
+}
+async function readFileTail(filePath, lines) {
+  return await plat.measure(`Read tail ${lines ?? "all"}L`, async () => {
+    try {
+      const content = await Bun.file(filePath).text();
+      if (!lines) {
+        return content;
+      }
+      const allLines = content.split(/\r?\n/);
+      const tailLines = allLines.slice(-lines);
+      return tailLines.join(`
+`);
+    } catch (error) {
+      throw new Error(`Error reading file: ${error}`);
+    }
+  }) ?? "";
+}
+function copyFile(src, dest) {
+  fs.copyFileSync(src, dest);
+}
+async function getProcessMemory(pid) {
+  const map = await getProcessBatchResources([pid]);
+  return map.get(pid)?.memory || 0;
+}
+async function getProcessBatchResources(pids) {
+  if (pids.length === 0)
+    return new Map;
+  return await plat.measure(`Batch resources (${pids.length} PIDs)`, async () => {
+    const resourceMap = new Map;
+    const pidSet = new Set(pids);
+    try {
+      if (isWindows()) {
+        const output = psExec(`Get-Process -Id ${pids.join(",")} -ErrorAction SilentlyContinue | Select-Object Id, WorkingSet64 | ForEach-Object { Write-Output "$($_.Id)|$($_.WorkingSet64)" }`);
+        for (const line of output.split(`
+`)) {
+          const sepIdx = line.indexOf("|");
+          if (sepIdx === -1)
+            continue;
+          const pid = parseInt(line.substring(0, sepIdx).trim());
+          const memory = parseInt(line.substring(sepIdx + 1).trim()) || 0;
+          if (!isNaN(pid) && pidSet.has(pid)) {
+            resourceMap.set(pid, { memory, cpu: 0 });
+          }
+        }
+      } else {
+        const result = await $`ps -eo pid,pcpu,rss`.nothrow().quiet().text();
+        const lines = result.trim().split(`
+`);
+        for (let i = 1;i < lines.length; i++) {
+          const line = lines[i].trim();
+          if (!line)
+            continue;
+          const [pidStr, cpuStr, rssStr] = line.split(/\s+/);
+          const pid = parseInt(pidStr);
+          const cpu = parseFloat(cpuStr) || 0;
+          const rss = parseInt(rssStr) || 0;
+          if (pidSet.has(pid)) {
+            resourceMap.set(pid, { memory: rss * 1024, cpu });
+          }
+        }
+      }
+    } catch (e) {}
+    return resourceMap;
+  }) ?? new Map;
+}
+function parseUnixListeningPorts(output) {
+  const ports = new Set;
+  for (const line of output.split(`
+`)) {
+    const portMatch = line.match(/:(\d+)\s+\(LISTEN\)/);
+    if (portMatch) {
+      ports.add(parseInt(portMatch[1]));
+    }
+  }
+  return Array.from(ports);
+}
+async function getProcessPorts(pid) {
+  try {
+    if (isWindows()) {
+      const result = await $`netstat -ano`.nothrow().quiet().text();
+      const ports = new Set;
+      for (const line of result.split(`
+`)) {
+        const match = line.match(/^\s*TCP\s+\S+:(\d+)\s+\S+\s+LISTENING\s+(\d+)/);
+        if (match && parseInt(match[2]) === pid) {
+          ports.add(parseInt(match[1]));
+        }
+      }
+      return Array.from(ports);
+    } else {
+      try {
+        const result2 = await $`ss -tlnp`.nothrow().quiet().text();
+        const ports = new Set;
+        for (const line of result2.split(`
+`)) {
+          if (line.includes(`pid=${pid}`)) {
+            const portMatch = line.match(/:(\d+)\s/);
+            if (portMatch) {
+              ports.add(parseInt(portMatch[1]));
+            }
+          }
+        }
+        if (ports.size > 0)
+          return Array.from(ports);
+      } catch {}
+      const result = await $`lsof -Pan -p ${pid} -iTCP -sTCP:LISTEN`.nothrow().quiet().text();
+      return parseUnixListeningPorts(result);
+    }
+  } catch {
+    return [];
+  }
+}
+var plat;
+var init_platform = __esm(() => {
+  plat = createMeasure("platform");
+});
+
+// src/db.ts
+var exports_db = {};
+__export(exports_db, {
+  updateProcessPid: () => updateProcessPid,
+  updateProcessEnv: () => updateProcessEnv,
+  saveTemplate: () => saveTemplate,
+  retryDatabaseOperation: () => retryDatabaseOperation,
+  removeProcessByName: () => removeProcessByName,
+  removeProcess: () => removeProcess,
+  removeDependency: () => removeDependency,
+  removeAllProcesses: () => removeAllProcesses,
+  removeAllDependencies: () => removeAllDependencies,
+  insertProcess: () => insertProcess,
+  getTemplate: () => getTemplate,
+  getStartOrder: () => getStartOrder,
+  getRecentHistory: () => getRecentHistory,
+  getProcessHistory: () => getProcessHistory,
+  getProcess: () => getProcess,
+  getDependents: () => getDependents,
+  getDependencyGraph: () => getDependencyGraph,
+  getDependencies: () => getDependencies,
+  getDbInfo: () => getDbInfo,
+  getAllTemplates: () => getAllTemplates,
+  getAllProcesses: () => getAllProcesses,
+  deleteTemplate: () => deleteTemplate,
+  dbPath: () => dbPath,
+  db: () => db,
+  clearOldHistory: () => clearOldHistory,
+  bgrHome: () => bgrHome,
+  addHistoryEntry: () => addHistoryEntry,
+  addDependency: () => addDependency,
+  TemplateSchema: () => TemplateSchema,
+  ProcessSchema: () => ProcessSchema,
+  HistorySchema: () => HistorySchema,
+  DependencySchema: () => DependencySchema
+});
+import { Database, z } from "sqlite-zod-orm";
+import { join as join2 } from "path";
+var {sleep } = globalThis.Bun;
+import { existsSync as existsSync2, copyFileSync as copyFileSync2 } from "fs";
+function shouldAutoMigrateLegacyDb() {
+  const raw = (process.env.BGRUN_DISABLE_LEGACY_MIGRATION || "").trim().toLowerCase();
+  return !(raw === "1" || raw === "true" || raw === "yes");
+}
+function getProcess(name) {
+  return db.process.select().where({ name }).orderBy("timestamp", "desc").limit(1).get() || null;
+}
+function getAllProcesses() {
+  return db.process.select().all();
+}
+function insertProcess(data) {
+  return db.process.insert({
+    ...data,
+    timestamp: new Date().toISOString()
+  });
+}
+function removeProcess(pid) {
+  const matches = db.process.select().where({ pid }).all();
+  for (const p of matches) {
+    db.process.delete(p.id);
+  }
+}
+function removeProcessByName(name) {
+  const matches = db.process.select().where({ name }).all();
+  for (const p of matches) {
+    db.process.delete(p.id);
+  }
+}
+function updateProcessPid(name, newPid) {
+  const proc = db.process.select().where({ name }).limit(1).get();
+  if (proc) {
+    db.process.update(proc.id, { pid: newPid });
+  }
+}
+function removeAllProcesses() {
+  const all = db.process.select().all();
+  for (const p of all) {
+    db.process.delete(p.id);
+  }
+}
+function updateProcessEnv(name, envJson) {
+  const proc = db.process.select().where({ name }).limit(1).get();
+  if (proc) {
+    db.process.update(proc.id, { env: envJson });
+  }
+}
+function getAllTemplates() {
+  return db.template.select().all();
+}
+function getTemplate(name) {
+  return db.template.select().where({ name }).limit(1).get() || null;
+}
+function saveTemplate(data) {
+  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 || ""
+    });
+  }
+}
+function deleteTemplate(name) {
+  const tmpl = db.template.select().where({ name }).limit(1).get();
+  if (tmpl) {
+    db.template.delete(tmpl.id);
+  }
+}
+function getProcessHistory(name, limit = 50) {
+  return db.history.select().where({ process_name: name }).orderBy("timestamp", "desc").limit(limit).all();
+}
+function addHistoryEntry(processName, event, pid, metadata = {}) {
+  return db.history.insert({
+    process_name: processName,
+    event,
+    pid,
+    metadata: JSON.stringify(metadata)
+  });
+}
+function getRecentHistory(limit = 100) {
+  return db.history.select().orderBy("timestamp", "desc").limit(limit).all();
+}
+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;
+}
+function getDependencies(processName) {
+  return db.dependency.select().where({ process_name: processName }).all().map((d) => d.depends_on);
+}
+function getDependents(processName) {
+  return db.dependency.select().where({ depends_on: processName }).all().map((d) => d.process_name);
+}
+function getDependencyGraph() {
+  const all = db.dependency.select().all();
+  const graph = {};
+  for (const dep of all) {
+    if (!graph[dep.process_name])
+      graph[dep.process_name] = [];
+    graph[dep.process_name].push(dep.depends_on);
+  }
+  return graph;
+}
+function addDependency(processName, dependsOn) {
+  if (processName === dependsOn)
+    return false;
+  const existing = db.dependency.select().where({ process_name: processName, depends_on: dependsOn }).limit(1).get();
+  if (existing)
+    return false;
+  if (wouldCreateCycle(processName, dependsOn))
+    return false;
+  db.dependency.insert({ process_name: processName, depends_on: dependsOn });
+  return true;
+}
+function removeDependency(processName, dependsOn) {
+  const matches = db.dependency.select().where({ process_name: processName, depends_on: dependsOn }).all();
+  for (const dep of matches) {
+    db.dependency.delete(dep.id);
+  }
+}
+function removeAllDependencies(processName) {
+  const matches = db.dependency.select().where({ process_name: processName }).all();
+  for (const dep of matches) {
+    db.dependency.delete(dep.id);
+  }
+}
+function wouldCreateCycle(processName, dependsOn) {
+  const graph = getDependencyGraph();
+  if (!graph[processName])
+    graph[processName] = [];
+  graph[processName].push(dependsOn);
+  const visited = new Set;
+  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;
+}
+function getStartOrder() {
+  const graph = getDependencyGraph();
+  const allProcesses = getAllProcesses().map((p) => p.name);
+  const allNames = new Set(allProcesses);
+  const inDegree = {};
+  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;
+      }
+    }
+  }
+  const queue = [];
+  for (const name of allNames) {
+    if ((inDegree[name] || 0) === 0)
+      queue.push(name);
+  }
+  const order = [];
+  while (queue.length > 0) {
+    queue.sort();
+    const current = queue.shift();
+    order.push(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;
+}
+function getDbInfo() {
+  return {
+    dbPath,
+    bgrHome,
+    dbFilename,
+    exists: existsSync2(dbPath)
+  };
+}
+async function retryDatabaseOperation(operation, maxRetries = 5, delay = 100) {
+  for (let attempt = 1;attempt <= maxRetries; attempt++) {
+    try {
+      return operation();
+    } catch (err) {
+      if (err?.code === "SQLITE_BUSY" && attempt < maxRetries) {
+        await sleep(delay * attempt);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error("Max retries reached for database operation");
+}
+var ProcessSchema, TemplateSchema, HistorySchema, DependencySchema, homePath, bgrDir, dbFilename, dbPath, bgrHome, legacyDbPath, db;
+var init_db = __esm(() => {
+  init_platform();
+  ProcessSchema = z.object({
+    pid: z.number(),
+    workdir: z.string(),
+    command: z.string(),
+    name: z.string(),
+    env: z.string(),
+    configPath: z.string().default(""),
+    stdout_path: z.string(),
+    stderr_path: z.string(),
+    timestamp: z.string().default(() => new Date().toISOString()),
+    group: z.string().default("")
+  });
+  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())
+  });
+  HistorySchema = z.object({
+    process_name: z.string(),
+    event: z.string(),
+    pid: z.number().optional(),
+    timestamp: z.string().default(() => new Date().toISOString()),
+    metadata: z.string().default("")
+  });
+  DependencySchema = z.object({
+    process_name: z.string(),
+    depends_on: z.string(),
+    created_at: z.string().default(() => new Date().toISOString())
+  });
+  homePath = getHomeDir();
+  bgrDir = join2(homePath, ".bgr");
+  ensureDir(bgrDir);
+  dbFilename = process.env.BGRUN_DB ?? "bgrun.sqlite";
+  dbPath = join2(bgrDir, dbFilename);
+  bgrHome = bgrDir;
+  legacyDbPath = join2(bgrDir, "bgr_v2.sqlite");
+  if (shouldAutoMigrateLegacyDb() && !existsSync2(dbPath) && existsSync2(legacyDbPath)) {
+    try {
+      copyFileSync2(legacyDbPath, dbPath);
+      console.log(`[bgrun] Migrated database: ${legacyDbPath} \u2192 ${dbPath}`);
+    } catch (e) {}
+  }
+  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"]
+    }
+  });
+});
+
+// src/utils.ts
+import * as fs2 from "fs";
+function parseEnvString(envString) {
+  const env = {};
+  envString.split(",").forEach((pair) => {
+    const [key, value] = pair.split("=");
+    if (key && value)
+      env[key] = value;
+  });
+  return env;
+}
+function calculateRuntime(startTime) {
+  const start = new Date(startTime).getTime();
+  const now = new Date().getTime();
+  const diffInMinutes = Math.floor((now - start) / (1000 * 60));
+  return `${diffInMinutes} minutes`;
+}
+async function getVersion() {
+  try {
+    const { join: join3 } = await import("path");
+    const pkgPath = join3(import.meta.dir, "../package.json");
+    const pkg = await Bun.file(pkgPath).json();
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function validateDirectory(directory) {
+  if (!directory || !fs2.existsSync(directory)) {
+    throw new Error(`Directory not found or invalid: '${directory}'`);
+  }
+}
+function tailFile(path, prefix, colorFn, lines) {
+  let position = 0;
+  let lastPartial = "";
+  if (!fs2.existsSync(path)) {
+    return () => {};
+  }
+  const fd = fs2.openSync(path, "r");
+  const printNewContent = () => {
+    try {
+      const stats = fs2.statSync(path);
+      if (stats.size <= position)
+        return;
+      const buffer = Buffer.alloc(stats.size - position);
+      fs2.readSync(fd, buffer, 0, buffer.length, position);
+      let content = buffer.toString();
+      content = lastPartial + content;
+      lastPartial = "";
+      const lineArray = content.split(/\r?\n/);
+      if (!content.endsWith(`
+`)) {
+        lastPartial = lineArray.pop() || "";
+      }
+      lineArray.forEach((line) => {
+        if (line) {
+          console.log(colorFn(prefix + line));
+        }
+      });
+      position = stats.size;
+    } catch (e) {}
+  };
+  const watcher = fs2.watch(path, { persistent: true }, (event) => {
+    if (event === "change") {
+      printNewContent();
+    }
+  });
+  printNewContent();
+  return () => {
+    watcher.close();
+    try {
+      fs2.closeSync(fd);
+    } catch {}
+  };
+}
+var init_utils = __esm(() => {
+  init_platform();
+});
+
+// src/deps.ts
+var exports_deps = {};
+__export(exports_deps, {
+  getUnmetDeps: () => getUnmetDeps,
+  getDependencies: () => getDependencies2,
+  buildDepGraph: () => buildDepGraph
+});
+function getDependencies2(envStr) {
+  const env = parseEnvString(envStr);
+  const raw = env.BGR_DEPENDS_ON || "";
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+async function buildDepGraph() {
+  const processes = getAllProcesses();
+  const nodeMap = new Map;
+  for (const proc of processes) {
+    const deps = getDependencies2(proc.env);
+    const alive = await isProcessRunning(proc.pid, proc.command);
+    nodeMap.set(proc.name, {
+      name: proc.name,
+      dependsOn: deps,
+      dependedBy: [],
+      running: alive,
+      pid: proc.pid
+    });
+  }
+  for (const node of nodeMap.values()) {
+    for (const dep of node.dependsOn) {
+      const depNode = nodeMap.get(dep);
+      if (depNode) {
+        depNode.dependedBy.push(node.name);
+      }
+    }
+  }
+  const inDegree = new Map;
+  for (const node of nodeMap.values()) {
+    inDegree.set(node.name, node.dependsOn.filter((d) => nodeMap.has(d)).length);
+  }
+  const queue = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0)
+      queue.push(name);
+  }
+  const order = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    order.push(current);
+    const node = nodeMap.get(current);
+    for (const dependent of node.dependedBy) {
+      const newDegree = (inDegree.get(dependent) || 0) - 1;
+      inDegree.set(dependent, newDegree);
+      if (newDegree === 0)
+        queue.push(dependent);
+    }
+  }
+  const hasCycle = order.length < nodeMap.size;
+  const cycleNodes = hasCycle ? [...nodeMap.keys()].filter((n) => !order.includes(n)) : undefined;
+  return {
+    nodes: [...nodeMap.values()],
+    order,
+    hasCycle,
+    cycleNodes
+  };
+}
+async function getUnmetDeps(name) {
+  const proc = getProcess(name);
+  if (!proc)
+    return [];
+  const deps = getDependencies2(proc.env);
+  const unmet = [];
+  for (const depName of deps) {
+    const depProc = getProcess(depName);
+    if (!depProc) {
+      unmet.push(depName);
+      continue;
+    }
+    const alive = await isProcessRunning(depProc.pid, depProc.command);
+    if (!alive) {
+      unmet.push(depName);
+    }
+  }
+  return unmet;
+}
+var init_deps = __esm(() => {
+  init_db();
+  init_platform();
+  init_utils();
+});
+
+// src/log-rotation.ts
+var exports_log_rotation = {};
+__export(exports_log_rotation, {
+  startLogRotation: () => startLogRotation,
+  rotateLogFile: () => rotateLogFile,
+  rotateAllLogs: () => rotateAllLogs
+});
+import { existsSync as existsSync4, statSync as statSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+function rotateLogFile(filePath, maxBytes = DEFAULT_MAX_BYTES, keepLines = DEFAULT_KEEP_LINES) {
+  try {
+    if (!existsSync4(filePath))
+      return false;
+    const stat = statSync2(filePath);
+    if (stat.size <= maxBytes)
+      return false;
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split(`
+`);
+    if (lines.length <= keepLines)
+      return false;
+    const truncated = lines.slice(-keepLines);
+    const header = `--- [bgrun] Log rotated at ${new Date().toISOString()} (was ${lines.length} lines, ${formatBytes(stat.size)}) ---
+`;
+    writeFileSync2(filePath, header + truncated.join(`
+`));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function rotateAllLogs(getProcesses, maxBytes = DEFAULT_MAX_BYTES, keepLines = DEFAULT_KEEP_LINES) {
+  const processes = getProcesses();
+  const rotated = [];
+  let checked = 0;
+  for (const proc of processes) {
+    if (proc.stdout_path) {
+      checked++;
+      if (rotateLogFile(proc.stdout_path, maxBytes, keepLines)) {
+        rotated.push(`${proc.name}/stdout`);
+      }
+    }
+    if (proc.stderr_path) {
+      checked++;
+      if (rotateLogFile(proc.stderr_path, maxBytes, keepLines)) {
+        rotated.push(`${proc.name}/stderr`);
+      }
+    }
+  }
+  return { rotated, checked };
+}
+function startLogRotation(getProcesses, intervalMs = DEFAULT_CHECK_INTERVAL_MS, maxBytes = DEFAULT_MAX_BYTES, keepLines = DEFAULT_KEEP_LINES) {
+  console.log(`[logs] Log rotation active: max ${formatBytes(maxBytes)}/file, keep ${keepLines} lines, check every ${intervalMs / 1000}s`);
+  return setInterval(() => {
+    const { rotated } = rotateAllLogs(getProcesses, maxBytes, keepLines);
+    if (rotated.length > 0) {
+      console.log(`[logs] Rotated ${rotated.length} log(s): ${rotated.join(", ")}`);
+    }
+  }, intervalMs);
+}
+function formatBytes(bytes) {
+  if (bytes >= 1e6)
+    return `${(bytes / 1e6).toFixed(1)}MB`;
+  if (bytes >= 1000)
+    return `${(bytes / 1000).toFixed(0)}KB`;
+  return `${bytes}B`;
+}
+var DEFAULT_MAX_BYTES, DEFAULT_KEEP_LINES = 5000, DEFAULT_CHECK_INTERVAL_MS = 60000;
+var init_log_rotation = __esm(() => {
+  DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+});
+
+// src/logger.ts
+import boxen from "boxen";
+import chalk from "chalk";
+function announce(message, title) {
+  console.log(boxen(message, {
+    padding: 1,
+    margin: 1,
+    borderColor: "green",
+    title: title || "bgrun",
+    titleAlignment: "center",
+    borderStyle: "round"
+  }));
+}
+function error(message) {
+  const text = message instanceof Error ? message.stack || message.message : String(message);
+  console.error(boxen(chalk.red(text), {
+    padding: 1,
+    margin: 1,
+    borderColor: "red",
+    title: "Error",
+    titleAlignment: "center",
+    borderStyle: "double"
+  }));
+  throw new BgrunError(text);
+}
+var BgrunError;
+var init_logger = __esm(() => {
+  BgrunError = class BgrunError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "BgrunError";
+    }
+  };
+});
+
+// src/config.ts
+function formatEnvKey(key) {
+  return key.toUpperCase().replace(/\./g, "_");
+}
+function flattenConfig(obj, prefix = "") {
+  return Object.keys(obj).reduce((acc, key) => {
+    const value = obj[key];
+    const newPrefix = prefix ? `${prefix}.${key}` : key;
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        const indexedPrefix = `${newPrefix}.${index}`;
+        if (typeof item === "object" && item !== null) {
+          Object.assign(acc, flattenConfig(item, indexedPrefix));
+        } else {
+          acc[formatEnvKey(indexedPrefix)] = String(item);
+        }
+      });
+    } else if (typeof value === "object" && value !== null) {
+      Object.assign(acc, flattenConfig(value, newPrefix));
+    } else {
+      acc[formatEnvKey(newPrefix)] = String(value);
+    }
+    return acc;
+  }, {});
+}
+async function parseConfigFile(configPath) {
+  const importPath = `${configPath}?t=${Date.now()}`;
+  const parsedConfig = await import(importPath).then((m) => m.default);
+  return flattenConfig(parsedConfig);
+}
+
+// src/commands/run.ts
+var {$: $2 } = globalThis.Bun;
+var {sleep: sleep2 } = globalThis.Bun;
+import { join as join3 } from "path";
+import { createMeasure as createMeasure2 } from "measure-fn";
+async function handleRun(options) {
+  const { command, directory, env, name, configPath, force, fetch, stdout, stderr } = options;
+  const existingProcess = name ? getProcess(name) : null;
+  if (name && existingProcess) {
+    const { getUnmetDeps: getUnmetDeps2 } = await Promise.resolve().then(() => (init_deps(), exports_deps));
+    const unmet = await getUnmetDeps2(name);
+    if (unmet.length > 0) {
+      await run.measure(`Start ${unmet.length} dependencies for "${name}"`, async () => {
+        for (const depName of unmet) {
+          const depProc = getProcess(depName);
+          if (depProc) {
+            announce(`\uD83D\uDCE6 Starting dependency "${depName}" for "${name}"`, "Dependency");
+            await handleRun({ action: "run", name: depName, force: true, remoteName: "" });
+          }
+        }
+      });
+    }
+  }
+  if (existingProcess) {
+    const finalDirectory2 = directory || existingProcess.workdir;
+    validateDirectory(finalDirectory2);
+    $2.cwd(finalDirectory2);
+    if (fetch) {
+      if (!__require("fs").existsSync(__require("path").join(finalDirectory2, ".git"))) {
+        error(`Cannot --fetch: '${finalDirectory2}' is not a Git repository.`);
+      }
+      await run.measure(`Git fetch "${name}"`, async () => {
+        try {
+          await $2`git fetch origin`;
+          const localHash = (await $2`git rev-parse HEAD`.text()).trim();
+          const remoteHash = (await $2`git rev-parse origin/$(git rev-parse --abbrev-ref HEAD)`.text()).trim();
+          if (localHash !== remoteHash) {
+            await $2`git pull origin $(git rev-parse --abbrev-ref HEAD)`;
+            announce("\uD83D\uDCE5 Pulled latest changes", "Git Update");
+          }
+        } catch (err) {
+          error(`Failed to pull latest changes: ${err}`);
+        }
+      });
+    }
+    const isRunning = await isProcessRunning(existingProcess.pid);
+    if (isRunning && !force) {
+      error(`Process '${name}' is currently running. Use --force to restart.`);
+    }
+    let detectedPorts = [];
+    if (isRunning) {
+      detectedPorts = await getProcessPorts(existingProcess.pid);
+    }
+    if (isRunning) {
+      await run.measure(`Terminate "${name}" (PID ${existingProcess.pid})`, async () => {
+        await terminateProcess(existingProcess.pid);
+        announce(`\uD83D\uDD25 Terminated existing process '${name}'`, "Process Terminated");
+      });
+    }
+    if (detectedPorts.length > 0) {
+      await run.measure(`Port cleanup [${detectedPorts.join(", ")}]`, async () => {
+        for (const port of detectedPorts) {
+          await killProcessOnPort(port);
+        }
+        for (const port of detectedPorts) {
+          const freed = await waitForPortFree(port, 5000);
+          if (!freed) {
+            await killProcessOnPort(port);
+            await waitForPortFree(port, 3000);
+          }
+        }
+      });
+    }
+    const cmdToMatch = existingProcess.command;
+    if (cmdToMatch) {
+      await run.measure("Zombie sweep", async () => {
+        try {
+          const cmdKeyword = cmdToMatch.split(" ")[1] || cmdToMatch;
+          const GENERIC_KEYWORDS = ["dev", "run", "start", "serve", "build", "test"];
+          if (GENERIC_KEYWORDS.includes(cmdKeyword.toLowerCase())) {
+            return;
+          }
+          const currentPid = process.pid;
+          const result = await psExec(`Get-CimInstance Win32_Process -Filter "Name='bun.exe'" | Where-Object { $_.CommandLine -match '${cmdKeyword.replace(/'/g, "''")}' -and $_.ProcessId -ne ${currentPid} } | Select-Object -ExpandProperty ProcessId`, 3000);
+          const zombiePids = result.split(`
+`).map((l) => parseInt(l.trim())).filter((n) => !isNaN(n) && n > 0 && n !== currentPid);
+          for (const zPid of zombiePids) {
+            await $2`taskkill /F /T /PID ${zPid}`.nothrow().quiet();
+          }
+          if (zombiePids.length > 0) {
+            announce(`\uD83E\uDDF9 Swept ${zombiePids.length} zombie process(es)`, "Zombie Cleanup");
+          }
+        } catch {}
+      });
+    }
+    await retryDatabaseOperation(() => removeProcessByName(name));
+  } else {
+    if (!directory || !name || !command) {
+      error("'directory', 'name', and 'command' parameters are required for new processes.");
+    }
+    validateDirectory(directory);
+    $2.cwd(directory);
+  }
+  const finalCommand = command || existingProcess.command;
+  const finalDirectory = directory || existingProcess?.workdir;
+  let finalEnv = env || (existingProcess ? parseEnvString(existingProcess.env) : {});
+  if (!("BGR_KEEP_ALIVE" in finalEnv)) {
+    finalEnv.BGR_KEEP_ALIVE = "true";
+  }
+  let finalConfigPath;
+  if (configPath !== undefined) {
+    finalConfigPath = configPath;
+  } else if (existingProcess) {
+    finalConfigPath = existingProcess.configPath;
+  } else {
+    finalConfigPath = ".config.toml";
+  }
+  if (finalConfigPath) {
+    const fullConfigPath = join3(finalDirectory, finalConfigPath);
+    if (await Bun.file(fullConfigPath).exists()) {
+      const configEnv = await run.measure(`Parse config "${finalConfigPath}"`, async () => {
+        try {
+          return await parseConfigFile(fullConfigPath);
+        } catch (err) {
+          console.warn(`Warning: Failed to parse config file ${finalConfigPath}: ${err.message}`);
+          return null;
+        }
+      });
+      if (configEnv) {
+        finalEnv = { ...finalEnv, ...configEnv };
+        console.log(`Loaded config from ${finalConfigPath}`);
+      }
+    } else {
+      console.log(`Config file '${finalConfigPath}' not found, continuing without it.`);
+    }
+  }
+  const stdoutPath = stdout || existingProcess?.stdout_path || join3(homePath2, ".bgr", `${name}-out.txt`);
+  Bun.write(stdoutPath, "");
+  const stderrPath = stderr || existingProcess?.stderr_path || join3(homePath2, ".bgr", `${name}-err.txt`);
+  Bun.write(stderrPath, "");
+  const actualPid = await run.measure(`Spawn "${name}" \u2192 ${finalCommand}`, async () => {
+    const newProcess = Bun.spawn(getShellCommand(finalCommand), {
+      env: { ...Bun.env, ...finalEnv },
+      cwd: finalDirectory,
+      stdout: Bun.file(stdoutPath),
+      stderr: Bun.file(stderrPath)
+    });
+    newProcess.unref();
+    await sleep2(100);
+    const pid = await findChildPid(newProcess.pid);
+    await sleep2(400);
+    return pid;
+  }) ?? 0;
+  await retryDatabaseOperation(() => insertProcess({
+    pid: actualPid,
+    workdir: finalDirectory,
+    command: finalCommand,
+    name,
+    env: Object.entries(finalEnv).map(([k, v]) => `${k}=${v}`).join(","),
+    configPath: finalConfigPath || "",
+    stdout_path: stdoutPath,
+    stderr_path: stderrPath
+  }));
+  announce(`${existingProcess ? "\uD83D\uDD04 Restarted" : "\uD83D\uDE80 Launched"} process "${name}" with PID ${actualPid}`, "Process Started");
+}
+var homePath2, run;
+var init_run = __esm(() => {
+  init_db();
+  init_platform();
+  init_logger();
+  init_utils();
+  homePath2 = getHomeDir();
+  run = createMeasure2("run");
+});
+
+// src/server.ts
+var exports_server = {};
+__export(exports_server, {
+  startServer: () => startServer,
+  guardRestartCounts: () => guardRestartCounts,
+  guardEvents: () => guardEvents
+});
+import path from "path";
+async function cleanupPort(port) {
+  if (process.platform !== "win32")
+    return port;
+  try {
+    const proc = Bun.spawn([
+      "powershell",
+      "-NoProfile",
+      "-Command",
+      `Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`
+    ], { stdout: "pipe", stderr: "pipe" });
+    const text = await new Response(proc.stdout).text();
+    const pid = parseInt(text.trim(), 10);
+    if (!pid || pid === process.pid)
+      return port;
+    const checkProc = Bun.spawn([
+      "powershell",
+      "-NoProfile",
+      "-Command",
+      `Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id`
+    ], { stdout: "pipe", stderr: "pipe" });
+    const checkText = await new Response(checkProc.stdout).text();
+    if (checkText.trim()) {
+      console.log(`[server] Killing PID ${pid} holding port ${port}`);
+      Bun.spawn(["taskkill", "/F", "/PID", String(pid)], { stdout: "pipe", stderr: "pipe" });
+      await Bun.sleep(1000);
+      return port;
+    } else {
+      const fallback = port + 1;
+      console.log(`[server] \u26A0 Port ${port} held by zombie PID ${pid} \u2014 falling back to port ${fallback}`);
+      return fallback;
+    }
+  } catch {
+    return port;
+  }
+}
+async function startServer() {
+  const { start } = await import("melina");
+  const appDir = path.join(import.meta.dir, "../dashboard/app");
+  const requestedPort = process.env.BUN_PORT ? parseInt(process.env.BUN_PORT, 10) : 3000;
+  _originalPort = requestedPort;
+  const resolvedPort = await cleanupPort(requestedPort);
+  _currentPort = resolvedPort;
+  const needsExplicitPort = process.env.BUN_PORT || resolvedPort !== requestedPort;
+  await start({
+    appDir,
+    defaultTitle: "bgrun Dashboard - Process Manager",
+    globalCss: path.join(appDir, "globals.css"),
+    ...needsExplicitPort && { port: resolvedPort }
+  });
+  startGuard();
+  const { startLogRotation: startLogRotation2 } = await Promise.resolve().then(() => (init_log_rotation(), exports_log_rotation));
+  startLogRotation2(() => getAllProcesses());
+  if (resolvedPort !== requestedPort) {
+    startStickyPortChecker();
+  }
+}
+function startStickyPortChecker() {
+  const CHECK_INTERVAL_MS = 60000;
+  console.log(`[server] Starting sticky port checker (original: ${_originalPort}, current: ${_currentPort})`);
+  setInterval(async () => {
+    if (_currentPort === _originalPort)
+      return;
+    try {
+      const proc = Bun.spawn([
+        "powershell",
+        "-NoProfile",
+        "-Command",
+        `Get-NetTCPConnection -LocalPort ${_originalPort} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`
+      ], { stdout: "pipe", stderr: "pipe" });
+      const text = await new Response(proc.stdout).text();
+      const pid = parseInt(text.trim(), 10);
+      if (!pid) {
+        console.log(`[server] \u2713 Original port ${_originalPort} is now available! Consider restarting to reclaim it.`);
+        _currentPort = _originalPort;
+      }
+    } catch {}
+  }, CHECK_INTERVAL_MS);
+}
+function startGuard() {
+  console.log(`[guard] \u2713 Built-in process guard started (checking every ${GUARD_INTERVAL_MS / 1000}s)`);
+  setInterval(async () => {
+    try {
+      const processes = getAllProcesses();
+      if (processes.length === 0)
+        return;
+      for (const proc of processes) {
+        if (GUARD_SKIP_NAMES.has(proc.name))
+          continue;
+        const env = proc.env ? parseEnvString(proc.env) : {};
+        if (env.BGR_KEEP_ALIVE !== "true")
+          continue;
+        const alive = await isProcessRunning(proc.pid, proc.command);
+        if (!alive) {
+          const now = Date.now();
+          const nextRestart = guardNextRestartTime.get(proc.name) || 0;
+          if (now < nextRestart)
+            continue;
+          console.log(`[guard] \u26A0 Guarded process "${proc.name}" (PID ${proc.pid}) is dead, restarting...`);
+          let success = false;
+          try {
+            await handleRun({
+              action: "run",
+              name: proc.name,
+              force: true,
+              remoteName: ""
+            });
+            success = true;
+            const prevCount = guardRestartCounts.get(proc.name) || 0;
+            const newCount = prevCount + 1;
+            guardRestartCounts.set(proc.name, newCount);
+            try {
+              addHistoryEntry(proc.name, "restart", undefined, { by: "guard", count: newCount });
+            } catch {}
+            guardEvents.unshift({ time: now, name: proc.name, action: "restart", success: true });
+            if (guardEvents.length > 100)
+              guardEvents.pop();
+            if (newCount > 5) {
+              const backoffSeconds = Math.min(30 * Math.pow(2, newCount - 6), 300);
+              guardNextRestartTime.set(proc.name, Date.now() + backoffSeconds * 1000);
+              console.log(`[guard] \u2713 Restarted "${proc.name}" (restart #${newCount}). Crash loop detected: next check delayed by ${backoffSeconds}s.`);
+            } else {
+              console.log(`[guard] \u2713 Restarted "${proc.name}" (restart #${newCount})`);
+            }
+          } catch (err) {
+            console.error(`[guard] \u2717 Failed to restart "${proc.name}": ${err.message}`);
+            guardEvents.unshift({ time: now, name: proc.name, action: "restart", success: false });
+            if (guardEvents.length > 100)
+              guardEvents.pop();
+          }
+        } else {
+          const prevCount = guardRestartCounts.get(proc.name) || 0;
+          if (prevCount > 0) {
+            const nextRestart = guardNextRestartTime.get(proc.name) || 0;
+            if (Date.now() > nextRestart + 60000) {
+              guardRestartCounts.delete(proc.name);
+              guardNextRestartTime.delete(proc.name);
+            }
+          }
+        }
+      }
+    } catch (err) {
+      console.error(`[guard] Error in guard loop: ${err.message}`);
+    }
+  }, GUARD_INTERVAL_MS);
+}
+var GUARD_INTERVAL_MS = 30000, GUARD_SKIP_NAMES, _g, guardRestartCounts, guardNextRestartTime, guardEvents, _originalPort = 3000, _currentPort = 3000;
+var init_server = __esm(() => {
+  init_db();
+  init_platform();
+  init_run();
+  init_utils();
+  GUARD_SKIP_NAMES = new Set(["bgr-dashboard", "bgr-guard"]);
+  _g = globalThis;
+  if (!_g.__bgrGuardRestartCounts)
+    _g.__bgrGuardRestartCounts = new Map;
+  if (!_g.__bgrGuardNextRestartTime)
+    _g.__bgrGuardNextRestartTime = new Map;
+  if (!_g.__bgrGuardEvents)
+    _g.__bgrGuardEvents = [];
+  guardRestartCounts = _g.__bgrGuardRestartCounts;
+  guardNextRestartTime = _g.__bgrGuardNextRestartTime;
+  guardEvents = _g.__bgrGuardEvents;
+});
+init_server();
+
+export {
+  startServer,
+  guardRestartCounts,
+  guardEvents
+};