bgrun 3.12.16 → 3.12.21

package/dist/server.js

@@ -16,49 +16,131 @@ var __export = (target, all) => {
 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
+// src/log-rotation.ts
+var exports_log_rotation = {};
+__export(exports_log_rotation, {
+  startLogRotation: () => startLogRotation,
+  rotateLogFile: () => rotateLogFile,
+  rotateAllLogs: () => rotateAllLogs
 });
+import { existsSync, statSync, readFileSync, writeFileSync } from "fs";
+function rotateLogFile(filePath, maxBytes = DEFAULT_MAX_BYTES, keepLines = DEFAULT_KEEP_LINES) {
+  try {
+    if (!existsSync(filePath))
+      return false;
+    const stat = statSync(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)}) ---
+`;
+    writeFileSync(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/platform.ts
 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`);
+async function psExec(command, timeoutMs = 3000) {
+  const tmpFile = join(os.tmpdir(), `bgr-ps-${Date.now()}-${Math.random().toString(36).substr(2, 9)}.ps1`);
   try {
-    fs.writeFileSync(tmpFile, command);
-    const result = Bun.spawnSync(["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", tmpFile]);
+    await Bun.write(tmpFile, command);
+    const proc = Bun.spawn([
+      "powershell",
+      "-NoProfile",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      tmpFile
+    ], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("PowerShell command timed out")), timeoutMs);
+    });
+    const resultPromise = new Promise(async (resolve, reject) => {
+      try {
+        const stdoutPromise = proc.stdout ? new Response(proc.stdout).text() : Promise.resolve("");
+        const stderrPromise = proc.stderr ? new Response(proc.stderr).text() : Promise.resolve("");
+        const exitCode = await proc.exited;
+        const stdout = await stdoutPromise;
+        const stderr = await stderrPromise;
+        if (exitCode === 0) {
+          resolve(stdout);
+        } else {
+          resolve(stderr || "");
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
     try {
-      fs.unlinkSync(tmpFile);
-    } catch {}
-    return result.stdout?.toString() || "";
-  } catch {
+      const result = await Promise.race([resultPromise, timeoutPromise]);
+      return result.trim();
+    } catch (error) {
+      return "";
+    } finally {
+      try {
+        await Bun.sleep(100);
+      } catch {}
+    }
+  } finally {
     try {
-      fs.unlinkSync(tmpFile);
+      fs.rmSync(tmpFile, { force: true });
     } catch {}
-    return "";
   }
 }
 function isWindows() {
@@ -80,7 +162,7 @@ async function isProcessRunning(pid, command) {
           process.kill(pid, 0);
           return true;
         } catch {
-          const output = psExec(`Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id`).trim();
+          const output = await psExec(`Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id`);
           return output === String(pid);
         }
       } else {
@@ -173,35 +255,6 @@ async function isPortFree(port) {
     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;
@@ -409,9 +462,6 @@ async function readFileTail(filePath, lines) {
     }
   }) ?? "";
 }
-function copyFile(src, dest) {
-  fs.copyFileSync(src, dest);
-}
 async function getProcessMemory(pid) {
   const map = await getProcessBatchResources([pid]);
   return map.get(pid)?.memory || 0;
@@ -424,7 +474,7 @@ async function getProcessBatchResources(pids) {
     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)" }`);
+        const output = await 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("|");
@@ -504,6 +554,21 @@ async function getProcessPorts(pid) {
     return [];
   }
 }
+async function resolvePidWithPorts(pid) {
+  const ports = await getProcessPorts(pid);
+  if (ports.length > 0 || !isWindows() || pid <= 0) {
+    return { pid, ports };
+  }
+  const childPid = await findChildPid(pid);
+  if (childPid === pid || childPid <= 0) {
+    return { pid, ports };
+  }
+  const childPorts = await getProcessPorts(childPid);
+  if (childPorts.length > 0) {
+    return { pid: childPid, ports: childPorts };
+  }
+  return { pid, ports };
+}
 var plat;
 var init_platform = __esm(() => {
   plat = createMeasure("platform");
@@ -548,7 +613,7 @@ __export(exports_db, {
 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";
+import { existsSync as existsSync3, copyFileSync as copyFileSync2 } from "fs";
 function shouldAutoMigrateLegacyDb() {
   const raw = (process.env.BGRUN_DISABLE_LEGACY_MIGRATION || "").trim().toLowerCase();
   return !(raw === "1" || raw === "true" || raw === "yes");
@@ -580,7 +645,7 @@ function removeProcessByName(name) {
 function updateProcessPid(name, newPid) {
   const proc = db.process.select().where({ name }).limit(1).get();
   if (proc) {
-    db.process.update(proc.id, { pid: newPid });
+    proc.update({ pid: newPid });
   }
 }
 function removeAllProcesses() {
@@ -592,7 +657,7 @@ function removeAllProcesses() {
 function updateProcessEnv(name, envJson) {
   const proc = db.process.select().where({ name }).limit(1).get();
   if (proc) {
-    db.process.update(proc.id, { env: envJson });
+    proc.update({ env: envJson });
   }
 }
 function getAllTemplates() {
@@ -748,7 +813,7 @@ function getDbInfo() {
     dbPath,
     bgrHome,
     dbFilename,
-    exists: existsSync2(dbPath)
+    exists: existsSync3(dbPath)
   };
 }
 async function retryDatabaseOperation(operation, maxRetries = 5, delay = 100) {
@@ -807,7 +872,7 @@ var init_db = __esm(() => {
   dbPath = join2(bgrDir, dbFilename);
   bgrHome = bgrDir;
   legacyDbPath = join2(bgrDir, "bgr_v2.sqlite");
-  if (shouldAutoMigrateLegacyDb() && !existsSync2(dbPath) && existsSync2(legacyDbPath)) {
+  if (shouldAutoMigrateLegacyDb() && !existsSync3(dbPath) && existsSync3(legacyDbPath)) {
     try {
       copyFileSync2(legacyDbPath, dbPath);
       console.log(`[bgrun] Migrated database: ${legacyDbPath} \u2192 ${dbPath}`);
@@ -828,486 +893,6 @@ var init_db = __esm(() => {
   });
 });
 
-// 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, {
@@ -1343,18 +928,20 @@ async function cleanupPort(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;
+  const rawRequestedPort = process.env.BUN_PORT?.trim();
+  const explicitPort = rawRequestedPort ? parseInt(rawRequestedPort, 10) : null;
+  const hasExplicitPort = explicitPort !== null && !isNaN(explicitPort) && explicitPort > 0;
+  const requestedPort = hasExplicitPort ? explicitPort : 3000;
   _originalPort = requestedPort;
-  const resolvedPort = await cleanupPort(requestedPort);
+  const resolvedPort = hasExplicitPort ? await cleanupPort(requestedPort) : requestedPort;
   _currentPort = resolvedPort;
-  const needsExplicitPort = process.env.BUN_PORT || resolvedPort !== requestedPort;
+  const needsExplicitPort = hasExplicitPort || 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) {
@@ -1383,92 +970,17 @@ function startStickyPortChecker() {
     } 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(() => {
+var guardRestartCounts, guardEvents, _originalPort = 3000, _currentPort = 3000;
+var init_server = __esm(async () => {
   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;
+  guardRestartCounts = new Map;
+  guardEvents = [];
+  if (import.meta.main) {
+    await startServer();
+  }
 });
-init_server();
+await init_server();
 
 export {
   startServer,