bgrun 3.12.15 → 3.12.21

package/dist/deploy.js

@@ -17,48 +17,59 @@ 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`);
+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 +91,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 +184,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 +391,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 +403,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 +483,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");
@@ -580,7 +574,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 +586,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() {
@@ -830,6 +824,8 @@ var init_db = __esm(() => {
 
 // src/utils.ts
 import * as fs2 from "fs";
+import * as os2 from "os";
+import { join as join3 } from "path";
 function parseEnvString(envString) {
   const env = {};
   envString.split(",").forEach((pair) => {
@@ -845,9 +841,92 @@ function calculateRuntime(startTime) {
   const diffInMinutes = Math.floor((now - start) / (1000 * 60));
   return `${diffInMinutes} minutes`;
 }
+function parseCommandEnv(command) {
+  const env = {};
+  const trimmed = command.trim();
+  const windowsSegments = trimmed.split(/&&/).map((segment) => segment.trim());
+  for (const segment of windowsSegments) {
+    const match = segment.match(/^set\s+([A-Za-z_][A-Za-z0-9_]*)=(.*)$/i);
+    if (!match)
+      break;
+    env[match[1]] = match[2].trim();
+  }
+  const unixPrefixRegex = /^(?:([A-Za-z_][A-Za-z0-9_]*)=([^\s]+)\s+)+/;
+  const unixPrefix = trimmed.match(unixPrefixRegex);
+  if (unixPrefix) {
+    const pairs = unixPrefix[0].trim().split(/\s+/);
+    for (const pair of pairs) {
+      const eqIdx = pair.indexOf("=");
+      if (eqIdx <= 0)
+        continue;
+      const key = pair.slice(0, eqIdx);
+      const value = pair.slice(eqIdx + 1);
+      if (key)
+        env[key] = value;
+    }
+  }
+  return env;
+}
+function getDeclaredPort(processEnv, command) {
+  const mergedEnv = { ...command ? parseCommandEnv(command) : {}, ...processEnv };
+  const raw = mergedEnv.PORT || mergedEnv.BUN_PORT || "";
+  const parsed = parseInt(raw, 10);
+  return !isNaN(parsed) && parsed > 0 ? parsed : null;
+}
+function buildManagedProcessEnv(parentEnv, processEnv = {}) {
+  const sanitizedParentEnv = {};
+  for (const [key, value] of Object.entries(parentEnv)) {
+    if (value === undefined)
+      continue;
+    if (INTERNAL_MANAGED_ENV_KEYS.includes(key))
+      continue;
+    sanitizedParentEnv[key] = value;
+  }
+  return { ...sanitizedParentEnv, ...processEnv };
+}
+function stringifyEnvString(env) {
+  return Object.entries(env).map(([key, value]) => `${key}=${value}`).join(",");
+}
+function getWatcherProcessName(targetName) {
+  return `${WATCHER_PREFIX}${encodeURIComponent(targetName)}`;
+}
+function getWatchedProcessName(watcherName) {
+  if (!watcherName.startsWith(WATCHER_PREFIX))
+    return null;
+  try {
+    return decodeURIComponent(watcherName.slice(WATCHER_PREFIX.length));
+  } catch {
+    return null;
+  }
+}
+function isWatcherProcessName(name) {
+  return getWatchedProcessName(name) !== null;
+}
+function isInternalProcessName(name) {
+  return name === "bgr-dashboard" || name === "bgr-guard" || isWatcherProcessName(name);
+}
+function getOperationLockPath(name) {
+  return join3(os2.homedir(), ".bgr", `${name}.operation.lock`);
+}
+function acquireProcessOperationLock(name) {
+  const lockPath = getOperationLockPath(name);
+  fs2.mkdirSync(join3(os2.homedir(), ".bgr"), { recursive: true });
+  fs2.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, time: Date.now() }));
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    try {
+      fs2.unlinkSync(lockPath);
+    } catch {}
+  };
+}
+function isProcessOperationLocked(name) {
+  return fs2.existsSync(getOperationLockPath(name));
+}
 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";
@@ -903,8 +982,10 @@ function tailFile(path, prefix, colorFn, lines) {
     } catch {}
   };
 }
+var INTERNAL_MANAGED_ENV_KEYS, WATCHER_PREFIX = "bgr-watch-";
 var init_utils = __esm(() => {
   init_platform();
+  INTERNAL_MANAGED_ENV_KEYS = ["BUN_PORT", "BGR_STDOUT", "BGR_STDERR"];
 });
 
 // src/deps.ts
@@ -996,6 +1077,13 @@ var init_deps = __esm(() => {
   init_utils();
 });
 
+// src/deploy.ts
+init_db();
+
+// src/commands/run.ts
+init_db();
+init_platform();
+
 // src/logger.ts
 import boxen from "boxen";
 import chalk from "chalk";
@@ -1009,6 +1097,13 @@ function announce(message, title) {
     borderStyle: "round"
   }));
 }
+
+class BgrunError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BgrunError";
+  }
+}
 function error(message) {
   const text = message instanceof Error ? message.stack || message.message : String(message);
   console.error(boxen(chalk.red(text), {
@@ -1021,15 +1116,9 @@ function error(message) {
   }));
   throw new BgrunError(text);
 }
-var BgrunError;
-var init_logger = __esm(() => {
-  BgrunError = class BgrunError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "BgrunError";
-    }
-  };
-});
+
+// src/commands/run.ts
+init_utils();
 
 // src/config.ts
 function formatEnvKey(key) {
@@ -1061,185 +1150,556 @@ async function parseConfigFile(configPath) {
   const parsedConfig = await import(importPath).then((m) => m.default);
   return flattenConfig(parsedConfig);
 }
+async function loadConfigEnv(directory, configPath = ".config.toml") {
+  const { join: join4 } = await import("path");
+  const fullConfigPath = join4(directory, configPath);
+  if (!await Bun.file(fullConfigPath).exists()) {
+    return {
+      configEnv: {},
+      fullConfigPath,
+      exists: false
+    };
+  }
+  return {
+    configEnv: await parseConfigFile(fullConfigPath),
+    fullConfigPath,
+    exists: true
+  };
+}
 
 // src/commands/run.ts
 var {$: $2 } = globalThis.Bun;
 var {sleep: sleep2 } = globalThis.Bun;
-import { join as join3 } from "path";
+import { join as join5 } 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: "" });
-          }
-        }
-      });
+
+// src/watcher.ts
+init_db();
+init_platform();
+import { join as join4 } from "path";
+
+// src/cli-helpers.ts
+init_db();
+var MONTH_NAMES = [
+  "january",
+  "february",
+  "march",
+  "april",
+  "may",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december"
+];
+var DAY_NAMES = [
+  "",
+  "first",
+  "second",
+  "third",
+  "fourth",
+  "fifth",
+  "sixth",
+  "seventh",
+  "eighth",
+  "ninth",
+  "tenth",
+  "eleventh",
+  "twelfth",
+  "thirteenth",
+  "fourteenth",
+  "fifteenth",
+  "sixteenth",
+  "seventeenth",
+  "eighteenth",
+  "nineteenth",
+  "twentieth",
+  "twenty-first",
+  "twenty-second",
+  "twenty-third",
+  "twenty-fourth",
+  "twenty-fifth",
+  "twenty-sixth",
+  "twenty-seventh",
+  "twenty-eighth",
+  "twenty-ninth",
+  "thirtieth",
+  "thirty-first"
+];
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function buildDateProcessName(now = new Date) {
+  const month = MONTH_NAMES[now.getMonth()] || "process";
+  const day = DAY_NAMES[now.getDate()] || "day";
+  return `${month}-${day}`;
+}
+function generateAutoProcessName(now = new Date) {
+  const baseName = buildDateProcessName(now);
+  if (!getProcess(baseName)) {
+    return baseName;
+  }
+  const timeSuffix = `${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}`;
+  const timeName = `${baseName}-${timeSuffix}`;
+  if (!getProcess(timeName)) {
+    return timeName;
+  }
+  for (let i = 1;i < 1000; i++) {
+    const candidate = `${timeName}-${i}`;
+    if (!getProcess(candidate)) {
+      return candidate;
     }
   }
-  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.`);
+  return `${timeName}-${Date.now()}`;
+}
+function shellQuoteArg(arg) {
+  if (process.platform === "win32") {
+    if (/^[A-Za-z0-9_./:\\-]+$/.test(arg))
+      return arg;
+    return `"${arg.replace(/"/g, "\\\"")}"`;
+  }
+  if (/^[A-Za-z0-9_./:-]+$/.test(arg))
+    return arg;
+  return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+function joinCommandArgs(args) {
+  return args.map(shellQuoteArg).join(" ");
+}
+
+// src/watcher.ts
+init_utils();
+var DEFAULT_INTERVAL_MS = 5000;
+var CRASH_THRESHOLD = 5;
+var MAX_BACKOFF_MS = 5 * 60000;
+var STABILITY_WINDOW_MS = 120000;
+function getWatcherLogPaths(watcherName) {
+  const homePath2 = getHomeDir();
+  return {
+    stdoutPath: join4(homePath2, ".bgr", `${watcherName}-out.txt`),
+    stderrPath: join4(homePath2, ".bgr", `${watcherName}-err.txt`)
+  };
+}
+async function findDetachedWatcherPid(targetName) {
+  if (process.platform !== "win32")
+    return null;
+  const escaped = targetName.replace(/'/g, "''");
+  const result = await psExec(`Get-CimInstance Win32_Process -Filter "Name='bun.exe'" | Where-Object { $_.CommandLine -like '*--_watch-process*' -and $_.CommandLine -like '*${escaped}*' } | Sort-Object -Property CreationDate -Descending | Select-Object -First 1 -ExpandProperty ProcessId`, 4000);
+  const pid = parseInt(result.trim(), 10);
+  return !isNaN(pid) && pid > 0 ? pid : null;
+}
+function getInternalWatcherCommand(targetName) {
+  const quotedTarget = shellQuoteArg(targetName);
+  return {
+    storedCommand: `bunx bgrun --_watch-process ${quotedTarget}`,
+    spawnCommand: `bunx bgrun --_watch-process ${quotedTarget}`
+  };
+}
+async function ensureProcessWatcher(targetName) {
+  if (!targetName || isInternalProcessName(targetName))
+    return;
+  const proc = getProcess(targetName);
+  if (!proc)
+    return;
+  const env = parseEnvString(proc.env || "");
+  if (env.BGR_KEEP_ALIVE !== "true") {
+    await stopProcessWatcher(targetName);
+    return;
+  }
+  const watcherName = getWatcherProcessName(targetName);
+  const existingWatcher = getProcess(watcherName);
+  if (existingWatcher && await isProcessRunning(existingWatcher.pid, existingWatcher.command)) {
+    return;
+  }
+  if (existingWatcher) {
+    await retryDatabaseOperation(() => removeProcessByName(watcherName));
+  }
+  const { stdoutPath, stderrPath } = getWatcherLogPaths(watcherName);
+  await Bun.write(stdoutPath, "");
+  await Bun.write(stderrPath, "");
+  const { storedCommand, spawnCommand } = getInternalWatcherCommand(targetName);
+  const newProcess = Bun.spawn(getShellCommand(spawnCommand), {
+    env: {
+      ...Bun.env,
+      BGR_STDOUT: stdoutPath,
+      BGR_STDERR: stderrPath
+    },
+    cwd: getHomeDir(),
+    stdout: "ignore",
+    stderr: "ignore",
+    detached: true
+  });
+  newProcess.unref();
+  await Bun.sleep(1000);
+  let actualPid = await findChildPid(newProcess.pid);
+  if (!await isProcessRunning(actualPid)) {
+    const detachedPid = await findDetachedWatcherPid(targetName);
+    if (detachedPid)
+      actualPid = detachedPid;
+  }
+  await retryDatabaseOperation(() => insertProcess({
+    pid: actualPid,
+    workdir: getHomeDir(),
+    command: storedCommand,
+    name: watcherName,
+    env: stringifyEnvString({ BGR_KEEP_ALIVE: "false", BGR_WATCH_TARGET: targetName }),
+    configPath: "",
+    stdout_path: stdoutPath,
+    stderr_path: stderrPath
+  }));
+}
+async function stopProcessWatcher(targetName) {
+  const watcherName = getWatcherProcessName(targetName);
+  const watcherProc = getProcess(watcherName);
+  if (!watcherProc)
+    return;
+  if (await isProcessRunning(watcherProc.pid, watcherProc.command)) {
+    await terminateProcess(watcherProc.pid, true);
+  }
+  await retryDatabaseOperation(() => removeProcessByName(watcherName));
+}
+async function syncProcessWatcher(targetName, env) {
+  if (!targetName || isInternalProcessName(targetName))
+    return;
+  if (env.BGR_KEEP_ALIVE === "true") {
+    await ensureProcessWatcher(targetName);
+  } else {
+    await stopProcessWatcher(targetName);
+  }
+}
+function getBackoffMs(restartCount) {
+  if (restartCount <= CRASH_THRESHOLD)
+    return 0;
+  const exponent = restartCount - CRASH_THRESHOLD;
+  return Math.min(30000 * Math.pow(2, exponent - 1), MAX_BACKOFF_MS);
+}
+async function cleanupWatcher(targetName) {
+  const watcherName = getWatcherProcessName(targetName);
+  await retryDatabaseOperation(() => removeProcessByName(watcherName));
+}
+async function startProcessWatcher(targetName, intervalMs = DEFAULT_INTERVAL_MS) {
+  const watcherName = getWatcherProcessName(targetName);
+  const releaseWatcherLock = acquireProcessOperationLock(watcherName);
+  let restartCount = 0;
+  let nextRestartAt = 0;
+  let lastSeenAliveAt = 0;
+  try {
+    console.log(`[watcher] Watching "${targetName}" every ${Math.round(intervalMs / 1000)}s`);
+    while (true) {
+      const proc = getProcess(targetName);
+      if (!proc) {
+        console.log(`[watcher] Target "${targetName}" removed; exiting watcher`);
+        break;
+      }
+      const env = parseEnvString(proc.env || "");
+      if (env.BGR_KEEP_ALIVE !== "true") {
+        console.log(`[watcher] Guard disabled for "${targetName}"; exiting watcher`);
+        break;
       }
-      await run.measure(`Git fetch "${name}"`, async () => {
+      if (proc.pid <= 0 || isProcessOperationLocked(targetName)) {
+        await Bun.sleep(intervalMs);
+        continue;
+      }
+      const alive = await isProcessRunning(proc.pid, proc.command);
+      if (!alive) {
+        const now = Date.now();
+        if (now < nextRestartAt) {
+          await Bun.sleep(intervalMs);
+          continue;
+        }
         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");
-          }
+          console.log(`[watcher] Restarting "${targetName}" after detected crash`);
+          await handleRun({
+            action: "run",
+            name: targetName,
+            force: true,
+            remoteName: ""
+          });
+          restartCount++;
+          const backoffMs = getBackoffMs(restartCount);
+          nextRestartAt = backoffMs > 0 ? now + backoffMs : 0;
+          lastSeenAliveAt = 0;
+          addHistoryEntry(targetName, "guard_restart", proc.pid, { by: watcherName, count: restartCount, backoffMs });
         } catch (err) {
-          error(`Failed to pull latest changes: ${err}`);
+          addHistoryEntry(targetName, "guard_restart_failed", proc.pid, { by: watcherName, error: err?.message || String(err) });
+          console.error(`[watcher] Failed to restart "${targetName}": ${err.message}`);
         }
-      });
-    }
-    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);
+      } else if (restartCount > 0) {
+        const now = Date.now();
+        if (!lastSeenAliveAt) {
+          lastSeenAliveAt = now;
+        } else if (now - lastSeenAliveAt >= STABILITY_WINDOW_MS) {
+          restartCount = 0;
+          nextRestartAt = 0;
+          lastSeenAliveAt = 0;
+        }
+      }
+      await Bun.sleep(intervalMs);
     }
-    if (isRunning) {
-      await run.measure(`Terminate "${name}" (PID ${existingProcess.pid})`, async () => {
-        await terminateProcess(existingProcess.pid);
-        announce(`\uD83D\uDD25 Terminated existing process '${name}'`, "Process Terminated");
-      });
+  } finally {
+    releaseWatcherLock();
+    await cleanupWatcher(targetName);
+  }
+}
+function getGuardRestartCounts() {
+  const counts = new Map;
+  const entries = db.history.select().where({ event: "guard_restart" }).all();
+  for (const entry of entries) {
+    counts.set(entry.process_name, (counts.get(entry.process_name) || 0) + 1);
+  }
+  return counts;
+}
+function getRecentGuardEvents(limit = 100) {
+  const rows = db.history.select().orderBy("timestamp", "desc").limit(limit * 4).all().filter((row) => row.event === "guard_restart" || row.event === "guard_restart_failed").slice(0, limit);
+  return rows.map((row) => ({
+    time: new Date(row.timestamp).getTime(),
+    name: row.process_name,
+    action: "restart",
+    success: row.event === "guard_restart"
+  }));
+}
+
+// src/commands/run.ts
+var homePath2 = getHomeDir();
+var run = createMeasure2("run");
+var INTERNAL_BUNX_PREFIX = "bunx bgrun";
+function resolveInternalBgrunCommand(command) {
+  const trimmed = command.trim();
+  if (!trimmed.startsWith("bgrun --_") && !trimmed.startsWith(`${INTERNAL_BUNX_PREFIX} --_`)) {
+    return command;
+  }
+  if (trimmed.startsWith(`${INTERNAL_BUNX_PREFIX} --_`)) {
+    return trimmed;
+  }
+  return `${INTERNAL_BUNX_PREFIX}${trimmed.slice("bgrun".length)}`;
+}
+async function handleRun(options) {
+  const {
+    command,
+    directory,
+    env,
+    name,
+    configPath,
+    force,
+    fetch,
+    stdout,
+    stderr
+  } = options;
+  const releaseOperationLock = name ? acquireProcessOperationLock(name) : () => {};
+  try {
+    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 (detectedPorts.length > 0) {
-      await run.measure(`Port cleanup [${detectedPorts.join(", ")}]`, async () => {
-        for (const port of detectedPorts) {
-          await killProcessOnPort(port);
+    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.`);
         }
-        for (const port of detectedPorts) {
-          const freed = await waitForPortFree(port, 5000);
-          if (!freed) {
-            await killProcessOnPort(port);
-            await waitForPortFree(port, 3000);
+        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 actualPid2 = existingProcess.pid;
+      if (!isRunning && !force) {
+        const reconciled = await reconcileProcessPids([
+          {
+            name,
+            pid: existingProcess.pid,
+            command: existingProcess.command,
+            workdir: existingProcess.workdir
+          }
+        ], new Set([existingProcess.pid]));
+        const newPid = reconciled.get(name);
+        if (newPid) {
+          console.log(`[run] Reconciled dead PID ${existingProcess.pid} to live PID ${newPid}`);
+          actualPid2 = newPid;
+          updateProcessPid(name, newPid);
         }
-      });
-    }
-    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;
+      }
+      let detectedPorts = [];
+      const actuallyRunning = await isProcessRunning(actualPid2);
+      if (actuallyRunning) {
+        detectedPorts = await getProcessPorts(actualPid2);
+      }
+      if (actuallyRunning) {
+        await run.measure(`Terminate "${name}" (PID ${actualPid2})`, async () => {
+          await terminateProcess(actualPid2);
+          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);
           }
-          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();
+          for (const port of detectedPorts) {
+            const freed = await waitForPortFree(port, 5000);
+            if (!freed) {
+              await killProcessOnPort(port);
+              await waitForPortFree(port, 3000);
+            }
           }
-          if (zombiePids.length > 0) {
-            announce(`\uD83E\uDDF9 Swept ${zombiePids.length} zombie process(es)`, "Zombie Cleanup");
+        });
+      }
+      const existingEnv = existingProcess.env ? parseEnvString(existingProcess.env) : {};
+      const declaredPort = getDeclaredPort(existingEnv, existingProcess.command);
+      if (declaredPort && !detectedPorts.includes(declaredPort)) {
+        await run.measure(`Declared port cleanup [${declaredPort}]`, async () => {
+          const portFree = await isPortFree(declaredPort);
+          if (!portFree) {
+            console.log(`[run] Declared port ${declaredPort} is busy (orphaned process), cleaning up...`);
+            await killProcessOnPort(declaredPort);
+            const freed = await waitForPortFree(declaredPort, 5000);
+            if (!freed) {
+              console.warn(`[run] Port ${declaredPort} still busy after cleanup, retrying...`);
+              await killProcessOnPort(declaredPort);
+              await waitForPortFree(declaredPort, 3000);
+            }
           }
-        } catch {}
-      });
+        });
+      }
+      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 -like '*${cmdKeyword.replace(/'/g, "''").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);
     }
-    await retryDatabaseOperation(() => removeProcessByName(name));
-  } else {
-    if (!directory || !name || !command) {
-      error("'directory', 'name', and 'command' parameters are required for new processes.");
+    const storedCommand = command || existingProcess.command;
+    const finalCommand = resolveInternalBgrunCommand(storedCommand);
+    const finalDirectory = directory || existingProcess?.workdir;
+    let finalEnv = env || (existingProcess ? parseEnvString(existingProcess.env) : {});
+    let finalConfigPath;
+    if (configPath !== undefined) {
+      finalConfigPath = configPath;
+    } else if (existingProcess) {
+      finalConfigPath = existingProcess.configPath;
+    } else {
+      finalConfigPath = ".config.toml";
     }
-    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 (finalConfigPath) {
+      const fullConfigPath = join5(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}`);
         }
-      });
-      if (configEnv) {
-        finalEnv = { ...finalEnv, ...configEnv };
-        console.log(`Loaded config from ${finalConfigPath}`);
+      } else {
+        console.log(`Config file '${finalConfigPath}' not found, continuing without it.`);
       }
-    } else {
-      console.log(`Config file '${finalConfigPath}' not found, continuing without it.`);
     }
+    const stdoutPath = stdout || existingProcess?.stdout_path || join5(homePath2, ".bgr", `${name}-out.txt`);
+    Bun.write(stdoutPath, "");
+    const stderrPath = stderr || existingProcess?.stderr_path || join5(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: buildManagedProcessEnv(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: stringifyEnvString(finalEnv),
+      configPath: finalConfigPath || "",
+      stdout_path: stdoutPath,
+      stderr_path: stderrPath
+    }));
+    if (!isInternalProcessName(name)) {
+      await syncProcessWatcher(name, finalEnv);
+    }
+    announce(`${existingProcess ? "\uD83D\uDD04 Restarted" : "\uD83D\uDE80 Launched"} process "${name}" with PID ${actualPid}`, "Process Started");
+  } finally {
+    releaseOperationLock();
   }
-  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/deploy.ts
-init_db();
-init_run();
+init_utils();
 var {$: $3 } = globalThis.Bun;
 function formatDeployToolError(manager, error2) {
   const raw = error2 instanceof Error ? error2.message : String(error2 ?? "Unknown error");
@@ -1250,7 +1710,7 @@ function formatDeployToolError(manager, error2) {
   return `Dependency install failed with ${manager}: ${raw}`;
 }
 function isInternalProcess(name) {
-  return name === "bgr-dashboard" || name === "bgr-guard";
+  return isInternalProcessName(name);
 }
 async function pathExists(path) {
   return await Bun.file(path).exists();