bgrun 3.12.11 → 3.12.13

package/dist/deps.js

@@ -0,0 +1,1004 @@
+// @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();
+});
+init_deps();
+
+export {
+  getUnmetDeps,
+  getDependencies2 as getDependencies,
+  buildDepGraph
+};