bgrun 3.12.15 → 3.12.21

package/dist/index.js

@@ -18,48 +18,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() {
@@ -81,7 +92,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 {
@@ -174,35 +185,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;
@@ -410,9 +392,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;
@@ -425,7 +404,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("|");
@@ -505,6 +484,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");
@@ -581,7 +575,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() {
@@ -593,7 +587,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() {
@@ -831,6 +825,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) => {
@@ -846,9 +842,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";
@@ -904,8 +983,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
@@ -1068,6 +1149,102 @@ var init_log_rotation = __esm(() => {
   DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
 });
 
+// src/server.ts
+var exports_server = {};
+__export(exports_server, {
+  startServer: () => startServer,
+  guardRestartCounts: () => guardRestartCounts,
+  guardEvents: () => guardEvents
+});
+import path from "path";
+async function cleanupPort(port) {
+  if (process.platform !== "win32")
+    return port;
+  try {
+    const occupiedBefore = !await isPortFree(port);
+    if (!occupiedBefore)
+      return port;
+    console.log(`[server] Reclaiming port ${port} before dashboard start`);
+    await killProcessOnPort(port);
+    const freed = await waitForPortFree(port, 8000);
+    if (freed)
+      return port;
+    console.warn(`[server] Port ${port} still busy after first cleanup; retrying`);
+    await killProcessOnPort(port);
+    const freedAfterRetry = await waitForPortFree(port, 5000);
+    if (freedAfterRetry)
+      return port;
+    const fallback = port + 1;
+    console.warn(`[server] \u26A0 Could not reclaim port ${port}; falling back to port ${fallback}`);
+    return fallback;
+  } catch {
+    return port;
+  }
+}
+async function startServer() {
+  const { start } = await import("melina");
+  const appDir = path.join(import.meta.dir, "../dashboard/app");
+  const 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 = hasExplicitPort ? await cleanupPort(requestedPort) : requestedPort;
+  _currentPort = resolvedPort;
+  const needsExplicitPort = hasExplicitPort || resolvedPort !== requestedPort;
+  await start({
+    appDir,
+    defaultTitle: "bgrun Dashboard - Process Manager",
+    globalCss: path.join(appDir, "globals.css"),
+    ...needsExplicitPort && { port: resolvedPort }
+  });
+  const { startLogRotation: startLogRotation2 } = await Promise.resolve().then(() => (init_log_rotation(), exports_log_rotation));
+  startLogRotation2(() => getAllProcesses());
+  if (resolvedPort !== requestedPort) {
+    startStickyPortChecker();
+  }
+}
+function startStickyPortChecker() {
+  const CHECK_INTERVAL_MS = 60000;
+  console.log(`[server] Starting sticky port checker (original: ${_originalPort}, current: ${_currentPort})`);
+  setInterval(async () => {
+    if (_currentPort === _originalPort)
+      return;
+    try {
+      const proc = Bun.spawn([
+        "powershell",
+        "-NoProfile",
+        "-Command",
+        `Get-NetTCPConnection -LocalPort ${_originalPort} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`
+      ], { stdout: "pipe", stderr: "pipe" });
+      const text = await new Response(proc.stdout).text();
+      const pid = parseInt(text.trim(), 10);
+      if (!pid) {
+        console.log(`[server] \u2713 Original port ${_originalPort} is now available! Consider restarting to reclaim it.`);
+        _currentPort = _originalPort;
+      }
+    } catch {}
+  }, CHECK_INTERVAL_MS);
+}
+var guardRestartCounts, guardEvents, _originalPort = 3000, _currentPort = 3000;
+var init_server = __esm(async () => {
+  init_db();
+  init_platform();
+  guardRestartCounts = new Map;
+  guardEvents = [];
+  if (import.meta.main) {
+    await startServer();
+  }
+});
+
+// src/index.ts
+init_utils();
+import { parseArgs } from "util";
+
+// src/commands/run.ts
+init_db();
+init_platform();
+
 // src/logger.ts
 import boxen from "boxen";
 import chalk from "chalk";
@@ -1081,6 +1258,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), {
@@ -1093,15 +1277,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) {
@@ -1133,516 +1311,553 @@ 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: fetch2, 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;
+    }
+  }
+  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;
   }
-  if (existingProcess) {
-    const finalDirectory2 = directory || existingProcess.workdir;
-    validateDirectory(finalDirectory2);
-    $2.cwd(finalDirectory2);
-    if (fetch2) {
-      if (!__require("fs").existsSync(__require("path").join(finalDirectory2, ".git"))) {
-        error(`Cannot --fetch: '${finalDirectory2}' is not a Git repository.`);
+  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 {}
-      });
-    }
-    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}`);
+        });
       }
+      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 {
-      console.log(`Config file '${finalConfigPath}' not found, continuing without it.`);
-    }
-  }
-  const stdoutPath = stdout || existingProcess?.stdout_path || join3(homePath2, ".bgr", `${name}-out.txt`);
-  Bun.write(stdoutPath, "");
-  const stderrPath = stderr || existingProcess?.stderr_path || join3(homePath2, ".bgr", `${name}-err.txt`);
-  Bun.write(stderrPath, "");
-  const actualPid = await run.measure(`Spawn "${name}" \u2192 ${finalCommand}`, async () => {
-    const newProcess = Bun.spawn(getShellCommand(finalCommand), {
-      env: { ...Bun.env, ...finalEnv },
-      cwd: finalDirectory,
-      stdout: Bun.file(stdoutPath),
-      stderr: Bun.file(stderrPath)
-    });
-    newProcess.unref();
-    await sleep2(100);
-    const pid = await findChildPid(newProcess.pid);
-    await sleep2(400);
-    return pid;
-  }) ?? 0;
-  await retryDatabaseOperation(() => insertProcess({
-    pid: actualPid,
-    workdir: finalDirectory,
-    command: finalCommand,
-    name,
-    env: Object.entries(finalEnv).map(([k, v]) => `${k}=${v}`).join(","),
-    configPath: finalConfigPath || "",
-    stdout_path: stdoutPath,
-    stderr_path: stderrPath
-  }));
-  announce(`${existingProcess ? "\uD83D\uDD04 Restarted" : "\uD83D\uDE80 Launched"} process "${name}" with PID ${actualPid}`, "Process Started");
-}
-var homePath2, run;
-var init_run = __esm(() => {
-  init_db();
-  init_platform();
-  init_logger();
-  init_utils();
-  homePath2 = getHomeDir();
-  run = createMeasure2("run");
-});
-
-// src/server.ts
-var exports_server = {};
-__export(exports_server, {
-  startServer: () => startServer,
-  guardRestartCounts: () => guardRestartCounts,
-  guardEvents: () => guardEvents
-});
-import path from "path";
-async function cleanupPort(port) {
-  if (process.platform !== "win32")
-    return port;
-  try {
-    const proc = Bun.spawn([
-      "powershell",
-      "-NoProfile",
-      "-Command",
-      `Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`
-    ], { stdout: "pipe", stderr: "pipe" });
-    const text = await new Response(proc.stdout).text();
-    const pid = parseInt(text.trim(), 10);
-    if (!pid || pid === process.pid)
-      return port;
-    const checkProc = Bun.spawn([
-      "powershell",
-      "-NoProfile",
-      "-Command",
-      `Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id`
-    ], { stdout: "pipe", stderr: "pipe" });
-    const checkText = await new Response(checkProc.stdout).text();
-    if (checkText.trim()) {
-      console.log(`[server] Killing PID ${pid} holding port ${port}`);
-      Bun.spawn(["taskkill", "/F", "/PID", String(pid)], { stdout: "pipe", stderr: "pipe" });
-      await Bun.sleep(1000);
-      return port;
+      if (!directory || !name || !command) {
+        error("'directory', 'name', and 'command' parameters are required for new processes.");
+      }
+      validateDirectory(directory);
+      $2.cwd(directory);
+    }
+    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 {
-      const fallback = port + 1;
-      console.log(`[server] \u26A0 Port ${port} held by zombie PID ${pid} \u2014 falling back to port ${fallback}`);
-      return fallback;
+      finalConfigPath = ".config.toml";
     }
-  } catch {
-    return port;
-  }
-}
-async function startServer() {
-  const { start } = await import("melina");
-  const appDir = path.join(import.meta.dir, "../dashboard/app");
-  const requestedPort = process.env.BUN_PORT ? parseInt(process.env.BUN_PORT, 10) : 3000;
-  _originalPort = requestedPort;
-  const resolvedPort = await cleanupPort(requestedPort);
-  _currentPort = resolvedPort;
-  const needsExplicitPort = process.env.BUN_PORT || resolvedPort !== requestedPort;
-  await start({
-    appDir,
-    defaultTitle: "bgrun Dashboard - Process Manager",
-    globalCss: path.join(appDir, "globals.css"),
-    ...needsExplicitPort && { port: resolvedPort }
-  });
-  startGuard();
-  const { startLogRotation: startLogRotation2 } = await Promise.resolve().then(() => (init_log_rotation(), exports_log_rotation));
-  startLogRotation2(() => getAllProcesses());
-  if (resolvedPort !== requestedPort) {
-    startStickyPortChecker();
-  }
-}
-function startStickyPortChecker() {
-  const CHECK_INTERVAL_MS = 60000;
-  console.log(`[server] Starting sticky port checker (original: ${_originalPort}, current: ${_currentPort})`);
-  setInterval(async () => {
-    if (_currentPort === _originalPort)
-      return;
-    try {
-      const proc = Bun.spawn([
-        "powershell",
-        "-NoProfile",
-        "-Command",
-        `Get-NetTCPConnection -LocalPort ${_originalPort} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`
-      ], { stdout: "pipe", stderr: "pipe" });
-      const text = await new Response(proc.stdout).text();
-      const pid = parseInt(text.trim(), 10);
-      if (!pid) {
-        console.log(`[server] \u2713 Original port ${_originalPort} is now available! Consider restarting to reclaim it.`);
-        _currentPort = _originalPort;
-      }
-    } catch {}
-  }, CHECK_INTERVAL_MS);
-}
-function startGuard() {
-  console.log(`[guard] \u2713 Built-in process guard started (checking every ${GUARD_INTERVAL_MS / 1000}s)`);
-  setInterval(async () => {
-    try {
-      const processes = getAllProcesses();
-      if (processes.length === 0)
-        return;
-      for (const proc of processes) {
-        if (GUARD_SKIP_NAMES.has(proc.name))
-          continue;
-        const env = proc.env ? parseEnvString(proc.env) : {};
-        if (env.BGR_KEEP_ALIVE !== "true")
-          continue;
-        const alive = await isProcessRunning(proc.pid, proc.command);
-        if (!alive) {
-          const now = Date.now();
-          const nextRestart = guardNextRestartTime.get(proc.name) || 0;
-          if (now < nextRestart)
-            continue;
-          console.log(`[guard] \u26A0 Guarded process "${proc.name}" (PID ${proc.pid}) is dead, restarting...`);
-          let success = false;
+    if (finalConfigPath) {
+      const fullConfigPath = join5(finalDirectory, finalConfigPath);
+      if (await Bun.file(fullConfigPath).exists()) {
+        const configEnv = await run.measure(`Parse config "${finalConfigPath}"`, async () => {
           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})`);
-            }
+            return await parseConfigFile(fullConfigPath);
           } 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);
-            }
+            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.`);
       }
-    } catch (err) {
-      console.error(`[guard] Error in guard loop: ${err.message}`);
     }
-  }, GUARD_INTERVAL_MS);
-}
-var GUARD_INTERVAL_MS = 30000, GUARD_SKIP_NAMES, _g, guardRestartCounts, guardNextRestartTime, guardEvents, _originalPort = 3000, _currentPort = 3000;
-var init_server = __esm(() => {
-  init_db();
-  init_platform();
-  init_run();
-  init_utils();
-  GUARD_SKIP_NAMES = new Set(["bgr-dashboard", "bgr-guard"]);
-  _g = globalThis;
-  if (!_g.__bgrGuardRestartCounts)
-    _g.__bgrGuardRestartCounts = new Map;
-  if (!_g.__bgrGuardNextRestartTime)
-    _g.__bgrGuardNextRestartTime = new Map;
-  if (!_g.__bgrGuardEvents)
-    _g.__bgrGuardEvents = [];
-  guardRestartCounts = _g.__bgrGuardRestartCounts;
-  guardNextRestartTime = _g.__bgrGuardNextRestartTime;
-  guardEvents = _g.__bgrGuardEvents;
-});
-
-// src/guard.ts
-var exports_guard = {};
-__export(exports_guard, {
-  startGuardLoop: () => startGuardLoop
-});
-import { createHmac } from "crypto";
-async function notifyWebhook(event, name, details) {
-  if (!WEBHOOK_URL)
-    return;
-  try {
-    const payload = JSON.stringify({
-      event,
-      process: name,
-      timestamp: new Date().toISOString(),
-      ...details
-    });
-    const headers = {
-      "Content-Type": "application/json",
-      "User-Agent": "bgrun-guard/1.0"
-    };
-    if (WEBHOOK_SECRET) {
-      const sig = createHmac("sha256", WEBHOOK_SECRET).update(payload).digest("hex");
-      headers["X-BGR-Signature"] = `sha256=${sig}`;
-    }
-    const controller = new AbortController;
-    const timeout = setTimeout(() => controller.abort(), 5000);
-    await fetch(WEBHOOK_URL, {
-      method: "POST",
-      headers,
-      body: payload,
-      signal: controller.signal
-    });
-    clearTimeout(timeout);
-  } catch (err) {
-    console.error(`[guard] Webhook failed: ${err.message}`);
-  }
-}
-async function restartProcess(name) {
-  try {
-    await handleRun({
-      action: "run",
+    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,
-      force: true,
-      remoteName: ""
-    });
-    return true;
-  } catch (err) {
-    console.error(`[guard] \u2717 Failed to restart "${name}": ${err.message}`);
-    return false;
-  }
-}
-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 guardCycle() {
-  try {
-    const processes = getAllProcesses();
-    if (processes.length === 0)
-      return;
-    const now = Date.now();
-    let checked = 0;
-    let restarted = 0;
-    let skipped = 0;
-    for (const proc of processes) {
-      if (proc.name === "bgr-guard")
-        continue;
-      const env = proc.env ? parseEnvString(proc.env) : {};
-      const isGuarded = env.BGR_KEEP_ALIVE === "true";
-      const isDashboard = proc.name === "bgr-dashboard";
-      if (!isGuarded && !isDashboard)
-        continue;
-      checked++;
-      try {
-        const alive = await isProcessRunning(proc.pid, proc.command);
-        if (!alive && proc.pid > 0) {
-          const nextRestart = state.nextRestartTime.get(proc.name) || 0;
-          if (now < nextRestart) {
-            const waitSecs = Math.round((nextRestart - now) / 1000);
-            skipped++;
-            continue;
-          }
-          console.log(`[guard] \u26A0 "${proc.name}" (PID ${proc.pid}) is dead \u2014 restarting...`);
-          notifyWebhook("crash", proc.name, { pid: proc.pid, isDashboard });
-          const success = await restartProcess(proc.name);
-          if (success) {
-            const count = (state.restartCounts.get(proc.name) || 0) + 1;
-            state.restartCounts.set(proc.name, count);
-            state.lastSeenAlive.delete(proc.name);
-            const backoff = getBackoffMs(count);
-            if (backoff > 0) {
-              state.nextRestartTime.set(proc.name, now + backoff);
-              console.log(`[guard] \u2713 Restarted "${proc.name}" (#${count}). Crash loop: next check in ${Math.round(backoff / 1000)}s`);
-            } else {
-              console.log(`[guard] \u2713 Restarted "${proc.name}" (#${count})`);
-            }
-            restarted++;
-            notifyWebhook("restart", proc.name, { pid: proc.pid, restartCount: count, backoffMs: backoff });
-          } else {
-            notifyWebhook("restart_failed", proc.name, { pid: proc.pid });
-          }
-        } else if (alive) {
-          const count = state.restartCounts.get(proc.name) || 0;
-          if (count > 0) {
-            const lastSeen = state.lastSeenAlive.get(proc.name);
-            if (!lastSeen) {
-              state.lastSeenAlive.set(proc.name, now);
-            } else if (now - lastSeen > STABILITY_WINDOW_MS) {
-              state.restartCounts.delete(proc.name);
-              state.nextRestartTime.delete(proc.name);
-              state.lastSeenAlive.delete(proc.name);
-              console.log(`[guard] \u2713 "${proc.name}" stable for ${Math.round(STABILITY_WINDOW_MS / 1000)}s \u2014 reset counters`);
-            }
-          }
-        }
-      } catch (err) {
-        console.error(`[guard] Error checking "${proc.name}": ${err.message}`);
-      }
-    }
-    if (restarted > 0) {
-      console.log(`[guard] Cycle: ${checked} checked, ${restarted} restarted, ${skipped} in backoff`);
+      env: stringifyEnvString(finalEnv),
+      configPath: finalConfigPath || "",
+      stdout_path: stdoutPath,
+      stderr_path: stderrPath
+    }));
+    if (!isInternalProcessName(name)) {
+      await syncProcessWatcher(name, finalEnv);
     }
-  } catch (err) {
-    console.error(`[guard] Error in guard cycle: ${err.message}`);
+    announce(`${existingProcess ? "\uD83D\uDD04 Restarted" : "\uD83D\uDE80 Launched"} process "${name}" with PID ${actualPid}`, "Process Started");
+  } finally {
+    releaseOperationLock();
   }
 }
-async function startGuardLoop(intervalMs = DEFAULT_INTERVAL_MS) {
-  const interval = intervalMs || DEFAULT_INTERVAL_MS;
-  console.log(`[guard] \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
-  console.log(`[guard] \uD83D\uDEE1\uFE0F  BGR Standalone Guard started`);
-  console.log(`[guard]    Check interval: ${interval / 1000}s`);
-  console.log(`[guard]    Crash backoff threshold: ${CRASH_THRESHOLD} restarts`);
-  console.log(`[guard]    Stability window: ${STABILITY_WINDOW_MS / 1000}s`);
-  console.log(`[guard]    Monitoring: BGR_KEEP_ALIVE=true + bgr-dashboard`);
-  console.log(`[guard]    Webhook: ${WEBHOOK_URL || "(none \u2014 set BGR_WEBHOOK_URL to enable)"}`);
-  console.log(`[guard]    Started: ${new Date().toLocaleString()}`);
-  console.log(`[guard] \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
-  await guardCycle();
-  setInterval(guardCycle, interval);
-}
-var WEBHOOK_URL, WEBHOOK_SECRET, DEFAULT_INTERVAL_MS = 30000, MAX_BACKOFF_MS, CRASH_THRESHOLD = 5, STABILITY_WINDOW_MS = 120000, state;
-var init_guard = __esm(() => {
-  init_db();
-  init_platform();
-  init_run();
-  init_utils();
-  WEBHOOK_URL = process.env.BGR_WEBHOOK_URL || "";
-  WEBHOOK_SECRET = process.env.BGR_WEBHOOK_SECRET || "";
-  MAX_BACKOFF_MS = 5 * 60000;
-  state = {
-    restartCounts: new Map,
-    nextRestartTime: new Map,
-    lastSeenAlive: new Map
-  };
-});
-
-// src/index.ts
-init_utils();
-init_run();
-import { parseArgs } from "util";
 
 // src/commands/list.ts
 import chalk3 from "chalk";
@@ -1812,7 +2027,6 @@ function renderProcessTable(processes, options) {
 
 // src/commands/list.ts
 init_db();
-init_logger();
 init_utils();
 init_platform();
 function formatMemory(bytes) {
@@ -1826,6 +2040,8 @@ function formatMemory(bytes) {
 async function showAll(opts) {
   const processes = getAllProcesses();
   const filtered = processes.filter((proc) => {
+    if (isInternalProcessName(proc.name))
+      return false;
     if (!opts?.filter)
       return true;
     const envVars = parseEnvString(proc.env);
@@ -1873,11 +2089,21 @@ async function showAll(opts) {
   for (const proc of filtered) {
     const isRunning = aliveCache.get(proc.pid) ?? await isProcessRunning(proc.pid, proc.command);
     const runtime = calculateRuntime(proc.timestamp);
-    const mem = isRunning ? resourceMap.get(proc.pid)?.memory || 0 : 0;
-    const ports = isRunning ? await getProcessPorts(proc.pid) : [];
+    let displayPid = proc.pid;
+    let ports = [];
+    if (isRunning) {
+      const resolved = await resolvePidWithPorts(proc.pid);
+      displayPid = resolved.pid;
+      ports = resolved.ports;
+      if (displayPid !== proc.pid) {
+        updateProcessPid(proc.name, displayPid);
+        proc.pid = displayPid;
+      }
+    }
+    const mem = isRunning ? resourceMap.get(displayPid)?.memory || resourceMap.get(proc.pid)?.memory || 0 : 0;
     tableData.push({
       id: proc.id,
-      pid: proc.pid,
+      pid: displayPid,
       name: proc.name,
       port: ports.length > 0 ? ports.map((p) => `:${p}`).join(",") : "-",
       memory: formatMemory(mem),
@@ -1909,7 +2135,7 @@ async function showAll(opts) {
 // src/commands/cleanup.ts
 init_db();
 init_platform();
-init_logger();
+init_utils();
 import * as fs3 from "fs";
 async function handleDelete(name) {
   const process2 = getProcess(name);
@@ -1921,6 +2147,9 @@ async function handleDelete(name) {
   if (isRunning) {
     await terminateProcess(process2.pid);
   }
+  if (!isInternalProcessName(name)) {
+    await stopProcessWatcher(name);
+  }
   if (fs3.existsSync(process2.stdout_path)) {
     try {
       fs3.unlinkSync(process2.stdout_path);
@@ -1941,6 +2170,12 @@ async function handleClean() {
   for (const proc of processes) {
     const running = await isProcessRunning(proc.pid);
     if (!running) {
+      const watched = getWatchedProcessName(proc.name);
+      if (watched) {
+        removeProcess(proc.pid);
+        cleanedCount++;
+        continue;
+      }
       removeProcess(proc.pid);
       cleanedCount++;
       if (fs3.existsSync(proc.stdout_path)) {
@@ -1969,18 +2204,33 @@ async function handleStop(name) {
     error(`No process found named '${name}'`);
     return;
   }
-  const isRunning = await isProcessRunning(proc.pid);
-  if (!isRunning) {
-    announce(`Process '${name}' is already stopped.`, "Process Stop");
-    return;
-  }
-  const ports = await getProcessPorts(proc.pid);
-  await terminateProcess(proc.pid);
-  for (const port of ports) {
-    await killProcessOnPort(port);
+  const releaseOperationLock = acquireProcessOperationLock(name);
+  try {
+    const isRunning = await isProcessRunning(proc.pid);
+    if (!isRunning) {
+      announce(`Process '${name}' is already stopped.`, "Process Stop");
+      return;
+    }
+    const ports = await getProcessPorts(proc.pid);
+    await terminateProcess(proc.pid);
+    for (const port of ports) {
+      await killProcessOnPort(port);
+    }
+    const procEnv = proc.env ? parseEnvString(proc.env) : {};
+    const declaredPort = getDeclaredPort(procEnv, proc.command);
+    if (declaredPort && !ports.includes(declaredPort)) {
+      const portFree = await isPortFree(declaredPort);
+      if (!portFree) {
+        console.log(`[stop] Declared port ${declaredPort} is busy (orphaned process), cleaning up...`);
+        await killProcessOnPort(declaredPort);
+        await waitForPortFree(declaredPort, 3000);
+      }
+    }
+    updateProcessPid(name, 0);
+    announce(`Process '${name}' has been stopped (kept in registry).`, "Process Stopped");
+  } finally {
+    releaseOperationLock();
   }
-  updateProcessPid(name, 0);
-  announce(`Process '${name}' has been stopped (kept in registry).`, "Process Stopped");
 }
 async function handleDeleteAll() {
   const processes = getAllProcesses();
@@ -1991,6 +2241,9 @@ async function handleDeleteAll() {
   let killedCount = 0;
   let portsFreed = 0;
   for (const proc of processes) {
+    if (!isInternalProcessName(proc.name)) {
+      await stopProcessWatcher(proc.name);
+    }
     const running = await isProcessRunning(proc.pid);
     if (running) {
       const ports = await getProcessPorts(proc.pid);
@@ -2006,6 +2259,18 @@ async function handleDeleteAll() {
         portsFreed++;
       }
     }
+    const procEnv = proc.env ? parseEnvString(proc.env) : {};
+    const declaredPort = getDeclaredPort(procEnv, proc.command);
+    if (declaredPort) {
+      const portFree = await isPortFree(declaredPort);
+      if (!portFree) {
+        console.log(`[nuke] Declared port ${declaredPort} is busy, cleaning up...`);
+        await killProcessOnPort(declaredPort);
+        const freed = await waitForPortFree(declaredPort, 3000);
+        if (freed)
+          portsFreed++;
+      }
+    }
     if (fs3.existsSync(proc.stdout_path)) {
       try {
         fs3.unlinkSync(proc.stdout_path);
@@ -2029,9 +2294,7 @@ async function handleDeleteAll() {
 // src/commands/watch.ts
 init_db();
 init_platform();
-init_logger();
 init_utils();
-init_run();
 import * as fs4 from "fs";
 import path2 from "path";
 import chalk4 from "chalk";
@@ -2221,7 +2484,6 @@ SIGINT received...`));
 
 // src/commands/logs.ts
 init_db();
-init_logger();
 init_platform();
 import chalk5 from "chalk";
 import * as fs5 from "fs";
@@ -2266,7 +2528,6 @@ async function showLogs(name, logType = "both", lines) {
 }
 
 // src/commands/details.ts
-init_logger();
 init_db();
 init_utils();
 init_platform();
@@ -2277,6 +2538,10 @@ async function showDetails(name) {
     error(`No process found named '${name}'`);
     return;
   }
+  if (isInternalProcessName(proc.name)) {
+    error(`'${name}' is an internal bgrun process.`);
+    return;
+  }
   let isRunning = await isProcessRunning(proc.pid, proc.command);
   if (!isRunning && proc.pid > 0) {
     const reconciled = await reconcileProcessPids([{ name: proc.name, pid: proc.pid, command: proc.command, workdir: proc.workdir }], new Set([proc.pid]));
@@ -2289,7 +2554,15 @@ async function showDetails(name) {
   }
   const runtime = calculateRuntime(proc.timestamp);
   const envVars = parseEnvString(proc.env);
-  const ports = isRunning ? await getProcessPorts(proc.pid) : [];
+  let ports = [];
+  if (isRunning) {
+    const resolved = await resolvePidWithPorts(proc.pid);
+    ports = resolved.ports;
+    if (resolved.pid !== proc.pid) {
+      updateProcessPid(proc.name, resolved.pid);
+      proc.pid = resolved.pid;
+    }
+  }
   const portDisplay = ports.length > 0 ? ports.map((p) => chalk6.hex("#FF6B6B")(`:${p}`)).join(", ") : null;
   const details = `
 ${chalk6.bold("Process Details:")}
@@ -2313,13 +2586,225 @@ ${Object.entries(envVars).map(([key, value]) => `${chalk6.cyan.bold(key)} = ${ch
   announce(details, `Process Details: ${name}`);
 }
 
+// src/commands/envit.ts
+function parseEnvitArgs(args) {
+  let directory;
+  let configPath;
+  let shell;
+  let help = false;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+      continue;
+    }
+    if (arg === "--directory") {
+      directory = args[++i];
+      if (!directory)
+        error("Missing value for --directory.");
+      continue;
+    }
+    if (arg.startsWith("--directory=")) {
+      directory = arg.slice("--directory=".length);
+      if (!directory)
+        error("Missing value for --directory.");
+      continue;
+    }
+    if (arg === "--config") {
+      configPath = args[++i];
+      if (!configPath)
+        error("Missing value for --config.");
+      continue;
+    }
+    if (arg.startsWith("--config=")) {
+      configPath = arg.slice("--config=".length);
+      if (!configPath)
+        error("Missing value for --config.");
+      continue;
+    }
+    if (arg === "--shell") {
+      const value = args[++i];
+      if (!value)
+        error("Missing value for --shell.");
+      shell = normalizeEnvitShell(value);
+      continue;
+    }
+    if (arg.startsWith("--shell=")) {
+      shell = normalizeEnvitShell(arg.slice("--shell=".length));
+      continue;
+    }
+    if (!configPath) {
+      configPath = arg;
+      continue;
+    }
+    error(`Unexpected argument '${arg}'. envit prints shell export commands and does not run a child process.`);
+  }
+  return { directory, configPath, shell, help };
+}
+function normalizeEnvitShell(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "powershell" || normalized === "pwsh" || normalized === "ps1")
+    return "powershell";
+  if (normalized === "cmd" || normalized === "bat")
+    return "cmd";
+  if (normalized === "sh" || normalized === "bash" || normalized === "zsh")
+    return "sh";
+  if (normalized === "json")
+    return "json";
+  error(`Unsupported shell '${value}'. Use powershell, cmd, sh, or json.`);
+}
+function detectEnvitShell() {
+  if (process.platform === "win32") {
+    return "powershell";
+  }
+  return "sh";
+}
+function escapePowerShell(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function escapeCmd(value) {
+  return value.replace(/"/g, '""');
+}
+function escapeSh(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function renderEnvitOutput(env, shell) {
+  if (shell === "json") {
+    return JSON.stringify(env, null, 2);
+  }
+  const lines = Object.entries(env).map(([key, value]) => {
+    if (shell === "powershell") {
+      return `$env:${key}=${escapePowerShell(value)}`;
+    }
+    if (shell === "cmd") {
+      return `set "${key}=${escapeCmd(value)}"`;
+    }
+    return `export ${key}=${escapeSh(value)}`;
+  });
+  return lines.join(`
+`);
+}
+async function handleEnvit(options) {
+  const cwd = options.directory || process.cwd();
+  const configPath = options.configPath || ".config.toml";
+  const shell = options.shell || detectEnvitShell();
+  const { configEnv, exists } = await loadConfigEnv(cwd, configPath);
+  if (!exists) {
+    error(`Config file '${configPath}' not found.`);
+  }
+  console.log(renderEnvitOutput(configEnv, shell));
+}
+
+// src/commands/inline.ts
+init_utils();
+function parseInlineArgs(args) {
+  let directory;
+  let configPath;
+  let help = false;
+  const commandArgs = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (commandArgs.length > 0) {
+      commandArgs.push(arg);
+      continue;
+    }
+    if (arg === "--") {
+      commandArgs.push(...args.slice(i + 1));
+      break;
+    }
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+      continue;
+    }
+    if (arg === "--directory") {
+      directory = args[++i];
+      if (!directory)
+        error("Missing value for --directory.");
+      continue;
+    }
+    if (arg.startsWith("--directory=")) {
+      directory = arg.slice("--directory=".length);
+      if (!directory)
+        error("Missing value for --directory.");
+      continue;
+    }
+    if (arg === "--config") {
+      configPath = args[++i];
+      if (!configPath)
+        error("Missing value for --config.");
+      continue;
+    }
+    if (arg.startsWith("--config=")) {
+      configPath = arg.slice("--config=".length);
+      if (!configPath)
+        error("Missing value for --config.");
+      continue;
+    }
+    commandArgs.push(...args.slice(i));
+    break;
+  }
+  return { directory, configPath, commandArgs, help };
+}
+async function handleInline(options) {
+  const cwd = options.directory || process.cwd();
+  const configPath = options.configPath || ".config.toml";
+  const { configEnv, exists } = await loadConfigEnv(cwd, configPath);
+  if (exists) {
+    console.log(`Loaded config from ${configPath}`);
+  } else {
+    console.log(`Config file '${configPath}' not found, continuing without it.`);
+  }
+  if (options.commandArgs.length === 0) {
+    error("Please provide a command to run. Example: bgrun inline -- bun run dev");
+  }
+  const proc = Bun.spawn(options.commandArgs, {
+    cwd,
+    env: buildManagedProcessEnv(Bun.env, configEnv),
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  process.exit(exitCode);
+}
+
+// src/commands/guard.ts
+init_db();
+init_utils();
+async function handleGuardToggle(targetName, enabled) {
+  if (!targetName) {
+    error(`Please provide a process name. Example: bunx bgrun myapp ${enabled ? "--guard" : "--guard-off"}`);
+  }
+  if (isInternalProcessName(targetName)) {
+    error(`'${targetName}' is an internal bgrun process.`);
+  }
+  const proc = getProcess(targetName);
+  if (!proc) {
+    error(`Process '${targetName}' not found.`);
+  }
+  const env = parseEnvString(proc.env || "");
+  const alreadyGuarded = env.BGR_KEEP_ALIVE === "true";
+  if (enabled) {
+    env.BGR_KEEP_ALIVE = "true";
+    await retryDatabaseOperation(() => updateProcessEnv(targetName, stringifyEnvString(env)));
+    await ensureProcessWatcher(targetName);
+    addHistoryEntry(targetName, "guard_on", proc.pid);
+    announce(alreadyGuarded ? `Guard is already active for '${targetName}'` : `\uD83D\uDEE1\uFE0F Guard enabled for '${targetName}'`, "Process Guard");
+    return;
+  }
+  delete env.BGR_KEEP_ALIVE;
+  await retryDatabaseOperation(() => updateProcessEnv(targetName, stringifyEnvString(env)));
+  await stopProcessWatcher(targetName);
+  addHistoryEntry(targetName, "guard_off", proc.pid);
+  announce(alreadyGuarded ? `\uD83D\uDED1 Guard disabled for '${targetName}'` : `Guard is already off for '${targetName}'`, "Process Guard");
+}
+
 // src/index.ts
-init_logger();
 init_platform();
 init_db();
 import dedent from "dedent";
 import chalk7 from "chalk";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 var {sleep: sleep3 } = globalThis.Bun;
 import { configure } from "measure-fn";
 if (!Bun.argv.includes("--_serve")) {
@@ -2367,32 +2852,49 @@ function redirectConsoleToFiles() {
     };
   }
 }
+async function findDetachedProcessByArg(snippet) {
+  if (process.platform !== "win32")
+    return null;
+  try {
+    const result = await psExec(`Get-CimInstance Win32_Process -Filter "Name='bun.exe'" | Where-Object { $_.CommandLine -match '${snippet.replace(/'/g, "''")}' } | Sort-Object -Property CreationDate -Descending | Select-Object -First 1 -ExpandProperty ProcessId`, 3000);
+    const pid = parseInt(result.trim(), 10);
+    return !isNaN(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
 async function showHelp() {
   const usage = dedent`
     ${chalk7.bold("bgrun \u2014 Bun Background Runner")}
     ${chalk7.gray("\u2550".repeat(50))}
 
     ${chalk7.yellow("Usage:")}
-      bgrun [name] [options]
+      bunx bgrun [name] [options]
 
     ${chalk7.yellow("Commands:")}
-      bgrun                     List all processes
-      bgrun [name]             Show details for a process
-      bgrun --dashboard        Launch web dashboard (managed by bgrun)
-      bgrun --guard            Launch standalone process guard
-      bgrun --restart [name]   Restart a process
-      bgrun --restart-all      Restart ALL registered processes
-      bgrun --stop [name]      Stop a process (keep in registry)
-      bgrun --stop-all         Stop ALL running processes
-      bgrun --delete [name]    Delete a process
-      bgrun --clean            Remove all stopped processes
-      bgrun --nuke             Delete ALL processes
+      bunx bgrun                     List all processes
+      bunx bgrun [name]             Show details for a process
+      bunx bgrun -- <cmd>           Start a managed process with an auto-generated name
+      bunx bgrun inline -- <cmd>    Run a command in this terminal with config env loaded
+      bunx bgrun --env              Print shell commands to export config env vars
+      bunx bgrun --dashboard        Launch web dashboard (managed by bgrun)
+      bunx bgrun [name] --guard     Enable crash watcher for a process
+      bunx bgrun [name] --guard-off Disable crash watcher for a process
+      bunx bgrun --restart [name]   Restart a process
+      bunx bgrun --restart-all      Restart ALL registered processes
+      bunx bgrun --stop [name]      Stop a process (keep in registry)
+      bunx bgrun --stop-all         Stop ALL running processes
+      bunx bgrun --delete [name]    Delete a process
+      bunx bgrun --clean            Remove all stopped processes
+      bunx bgrun --nuke             Delete ALL processes
 
     ${chalk7.yellow("Options:")}
       --name <string>        Process name (required for new)
       --command <string>     Process command (required for new)
       --directory <path>     Working directory (required for new)
       --config <path>        Config file (default: .config.toml)
+      --env                  Print shell export commands from config and exit
+      --shell <type>         Shell for --env: powershell | cmd | sh | json
       --watch                Watch for file changes and auto-restart
       --force                Force restart existing process
       --fetch                Fetch latest git changes before running
@@ -2405,85 +2907,187 @@ async function showHelp() {
       --version              Show version
       --debug                Show debug info (DB path, BGR home, etc.)
       --dashboard            Launch web dashboard as bgrun-managed process
+      --guard                Enable per-process crash watcher
+      --guard-off            Disable per-process crash watcher
       --port <number>        Port for dashboard (default: 3000)
       --help                 Show this help message
 
     ${chalk7.yellow("Examples:")}
-      bgrun --dashboard
-      bgrun --name myapp --command "bun run dev" --directory . --watch
-      bgrun myapp --logs --lines 50
+      bunx bgrun -- bun run dev
+      bunx bgrun --force -- bun run server.ts
+      bunx bgrun inline -- bun run dev
+      Invoke-Expression (bunx bgrun --env)
+      eval "$(bunx bgrun --env --shell sh)"
+      bunx bgrun --dashboard
+      bunx bgrun myapp --guard
+      bunx bgrun myapp --guard-off
+      bunx bgrun --name myapp --command "bun run dev" --directory . --watch
+      bunx bgrun myapp --logs --lines 50
   `;
   console.log(usage);
 }
+var cliArgOptions = {
+  name: { type: "string" },
+  command: { type: "string" },
+  directory: { type: "string" },
+  config: { type: "string" },
+  env: { type: "boolean" },
+  shell: { type: "string" },
+  watch: { type: "boolean" },
+  force: { type: "boolean" },
+  fetch: { type: "boolean" },
+  delete: { type: "boolean" },
+  nuke: { type: "boolean" },
+  restart: { type: "boolean" },
+  "restart-all": { type: "boolean" },
+  stop: { type: "boolean" },
+  "stop-all": { type: "boolean" },
+  clean: { type: "boolean" },
+  json: { type: "boolean" },
+  logs: { type: "boolean" },
+  "log-stdout": { type: "boolean" },
+  "log-stderr": { type: "boolean" },
+  lines: { type: "string" },
+  filter: { type: "string" },
+  version: { type: "boolean" },
+  help: { type: "boolean" },
+  db: { type: "string" },
+  stdout: { type: "string" },
+  stderr: { type: "string" },
+  dashboard: { type: "boolean" },
+  guard: { type: "boolean" },
+  "guard-off": { type: "boolean" },
+  debug: { type: "boolean" },
+  _serve: { type: "boolean" },
+  "_watch-process": { type: "string" },
+  port: { type: "string" }
+};
 async function run2() {
+  const rawArgs = Bun.argv.slice(2);
+  const isActionInvocation = (values2) => {
+    return Boolean(values2.dashboard || values2.guard || values2["guard-off"] || values2.version || values2.help || values2.debug || values2.nuke || values2.clean || values2["restart-all"] || values2["stop-all"] || values2.delete || values2.restart || values2.stop || values2.logs || values2["log-stdout"] || values2["log-stderr"] || values2.watch || values2.json || values2.filter);
+  };
+  if (rawArgs[0] === "inline") {
+    const parsed = parseInlineArgs(rawArgs.slice(1));
+    if (parsed.help) {
+      console.log(dedent`
+        ${chalk7.bold("bgrun inline")}
+        ${chalk7.gray("\u2500".repeat(40))}
+
+        Run a command in the current terminal with env vars loaded from a bgrun config file.
+
+        Usage:
+          bunx bgrun inline [--directory <path>] [--config <path>] -- <command> [args...]
+
+        Examples:
+          bunx bgrun inline -- bun run dev
+          bunx bgrun inline --directory apps/api -- node server.js
+      `);
+      return;
+    }
+    await handleInline(parsed);
+    return;
+  }
+  const delimiterIndex = rawArgs.indexOf("--");
+  if (delimiterIndex !== -1 && delimiterIndex < rawArgs.length - 1) {
+    const preArgs = rawArgs.slice(0, delimiterIndex);
+    const commandArgs = rawArgs.slice(delimiterIndex + 1);
+    const { values: values2 } = parseArgs({
+      args: preArgs,
+      options: cliArgOptions,
+      strict: false,
+      allowPositionals: true
+    });
+    const autoName = values2.name || generateAutoProcessName();
+    const inlineCommand = joinCommandArgs(commandArgs);
+    const directory = values2.directory || process.cwd();
+    await handleRun({
+      action: "run",
+      name: autoName,
+      command: inlineCommand,
+      directory,
+      configPath: values2.config,
+      force: values2.force,
+      fetch: values2.fetch,
+      remoteName: "",
+      dbPath: values2.db,
+      stdout: values2.stdout,
+      stderr: values2.stderr
+    });
+    return;
+  }
   const { values, positionals } = parseArgs({
-    args: Bun.argv.slice(2),
-    options: {
-      name: { type: "string" },
-      command: { type: "string" },
-      directory: { type: "string" },
-      config: { type: "string" },
-      watch: { type: "boolean" },
-      force: { type: "boolean" },
-      fetch: { type: "boolean" },
-      delete: { type: "boolean" },
-      nuke: { type: "boolean" },
-      restart: { type: "boolean" },
-      "restart-all": { type: "boolean" },
-      stop: { type: "boolean" },
-      "stop-all": { type: "boolean" },
-      clean: { type: "boolean" },
-      json: { type: "boolean" },
-      logs: { type: "boolean" },
-      "log-stdout": { type: "boolean" },
-      "log-stderr": { type: "boolean" },
-      lines: { type: "string" },
-      filter: { type: "string" },
-      version: { type: "boolean" },
-      help: { type: "boolean" },
-      db: { type: "string" },
-      stdout: { type: "string" },
-      stderr: { type: "string" },
-      dashboard: { type: "boolean" },
-      guard: { type: "boolean" },
-      debug: { type: "boolean" },
-      _serve: { type: "boolean" },
-      "_guard-loop": { type: "boolean" },
-      port: { type: "string" }
-    },
+    args: rawArgs,
+    options: cliArgOptions,
     strict: false,
     allowPositionals: true
   });
+  if (values.env) {
+    if (positionals.length > 1) {
+      error("Too many positional arguments for --env. Use --config <path> or pass a single config path.");
+    }
+    await handleEnvit({
+      directory: values.directory,
+      configPath: values.config || positionals[0],
+      shell: values.shell
+    });
+    return;
+  }
+  if (positionals.length > 1 && !values.command && !isActionInvocation(values)) {
+    const autoName = values.name || generateAutoProcessName();
+    const implicitCommand = joinCommandArgs(positionals);
+    const directory = values.directory || process.cwd();
+    await handleRun({
+      action: "run",
+      name: autoName,
+      command: implicitCommand,
+      directory,
+      configPath: values.config,
+      force: values.force,
+      fetch: values.fetch,
+      remoteName: "",
+      dbPath: values.db,
+      stdout: values.stdout,
+      stderr: values.stderr
+    });
+    return;
+  }
   if (values["_serve"]) {
     redirectConsoleToFiles();
-    const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
+    const { startServer: startServer2 } = await init_server().then(() => exports_server);
     await startServer2();
     return;
   }
-  if (values["_guard-loop"]) {
+  if (values["_watch-process"]) {
     redirectConsoleToFiles();
-    const { startGuardLoop: startGuardLoop2 } = await Promise.resolve().then(() => (init_guard(), exports_guard));
-    const intervalStr = positionals[0];
-    const intervalMs = intervalStr ? parseInt(intervalStr) * 1000 : undefined;
-    await startGuardLoop2(intervalMs);
+    await startProcessWatcher(String(values["_watch-process"]));
     return;
   }
   if (values.dashboard) {
     const dashboardName = "bgr-dashboard";
     const homePath3 = getHomeDir();
-    const bgrDir2 = join4(homePath3, ".bgr");
+    const bgrDir2 = join6(homePath3, ".bgr");
     const requestedPort = values.port;
+    const explicitPortValue = requestedPort || Bun.env.BUN_PORT || undefined;
+    const explicitPort = explicitPortValue ? parseInt(explicitPortValue, 10) : null;
     const existing = getProcess(dashboardName);
     if (existing && await isProcessRunning(existing.pid)) {
-      let existingPorts = await getProcessPorts(existing.pid);
+      const resolved = await resolvePidWithPorts(existing.pid);
+      let existingPid = resolved.pid;
+      let existingPorts = resolved.ports;
       if (existingPorts.length === 0) {
-        const childPid = await findChildPid(existing.pid);
-        if (childPid !== existing.pid) {
-          existingPorts = await getProcessPorts(childPid);
+        const detachedPid = await findDetachedProcessByArg("--_serve");
+        if (detachedPid && detachedPid !== existingPid) {
+          const detachedResolved = await resolvePidWithPorts(detachedPid);
+          existingPid = detachedResolved.pid;
+          existingPorts = detachedResolved.ports;
         }
       }
+      if (existingPid !== existing.pid && existingPorts.length > 0) {
+        await retryDatabaseOperation(() => updateProcessPid(dashboardName, existingPid));
+      }
       const portStr = existingPorts.length > 0 ? `:${existingPorts[0]}` : "(detecting...)";
-      announce(`Dashboard is already running (PID ${existing.pid})
+      announce(`Dashboard is already running (PID ${existingPid})
 
 ` + `  \uD83C\uDF10  ${chalk7.cyan(`http://localhost${portStr}`)}
 
@@ -2502,29 +3106,28 @@ async function run2() {
       }
       await retryDatabaseOperation(() => removeProcessByName(dashboardName));
     }
-    const { resolve } = __require("path");
-    const scriptPath = resolve(process.argv[1]);
-    const spawnCommand = `bun run ${scriptPath} --_serve`;
-    const command = `bgrun --_serve`;
-    const stdoutPath = join4(bgrDir2, `${dashboardName}-out.txt`);
-    const stderrPath = join4(bgrDir2, `${dashboardName}-err.txt`);
+    const spawnCommand = `bunx bgrun --_serve`;
+    const command = `bunx bgrun --_serve`;
+    const stdoutPath = join6(bgrDir2, `${dashboardName}-out.txt`);
+    const stderrPath = join6(bgrDir2, `${dashboardName}-err.txt`);
     await Bun.write(stdoutPath, "");
     await Bun.write(stderrPath, "");
     const spawnEnv = { ...Bun.env };
-    if (requestedPort) {
-      spawnEnv.BUN_PORT = requestedPort;
+    if (explicitPortValue) {
+      spawnEnv.BUN_PORT = explicitPortValue;
+    } else {
+      delete spawnEnv.BUN_PORT;
     }
     spawnEnv.BGR_STDOUT = stdoutPath;
     spawnEnv.BGR_STDERR = stderrPath;
-    const targetPort = parseInt(requestedPort || Bun.env.BUN_PORT || "3000");
-    if (!isNaN(targetPort) && targetPort > 0) {
-      const portFree = await isPortFree(targetPort);
+    if (explicitPort && explicitPort > 0) {
+      const portFree = await isPortFree(explicitPort);
       if (!portFree) {
-        console.log(chalk7.yellow(`  \u26A1 Port ${targetPort} is occupied \u2014 reclaiming...`));
-        await killProcessOnPort(targetPort);
-        const freed = await waitForPortFree(targetPort, 5000);
+        console.log(chalk7.yellow(`  \u26A1 Requested dashboard port ${explicitPort} is occupied \u2014 reclaiming...`));
+        await killProcessOnPort(explicitPort);
+        const freed = await waitForPortFree(explicitPort, 5000);
         if (!freed) {
-          console.log(chalk7.red(`  \u26A0 Could not free port ${targetPort} \u2014 dashboard may pick a fallback port`));
+          console.log(chalk7.red(`  \u26A0 Could not free port ${explicitPort} \u2014 dashboard may pick a fallback port`));
         }
       }
     }
@@ -2537,15 +3140,24 @@ async function run2() {
     });
     newProcess.unref();
     await sleep3(2000);
-    const resolvedPort = parseInt(requestedPort || Bun.env.BUN_PORT || "3000");
-    const actualPid = await findPidByPort(resolvedPort, 1e4) ?? await findChildPid(newProcess.pid);
+    let actualPid = explicitPort && explicitPort > 0 ? await findPidByPort(explicitPort, 1e4) ?? await findChildPid(newProcess.pid) : await findChildPid(newProcess.pid);
+    if (!await isProcessRunning(actualPid)) {
+      const detachedPid = await findDetachedProcessByArg("--_serve");
+      if (detachedPid)
+        actualPid = detachedPid;
+    }
     let actualPort = null;
     for (let attempt = 0;attempt < 10; attempt++) {
-      const ports = await getProcessPorts(actualPid);
-      if (ports.length > 0) {
-        actualPort = ports[0];
+      const resolved = await resolvePidWithPorts(actualPid);
+      actualPid = resolved.pid;
+      if (resolved.ports.length > 0) {
+        actualPort = resolved.ports[0];
         break;
       }
+      const detachedPid = await findDetachedProcessByArg("--_serve");
+      if (detachedPid && detachedPid !== actualPid) {
+        actualPid = detachedPid;
+      }
       await sleep3(1000);
     }
     await retryDatabaseOperation(() => insertProcess({
@@ -2578,75 +3190,8 @@ async function run2() {
     announce(msg, "BGR Dashboard");
     return;
   }
-  if (values.guard) {
-    const guardName = "bgr-guard";
-    const homePath3 = getHomeDir();
-    const bgrDir2 = join4(homePath3, ".bgr");
-    const existing = getProcess(guardName);
-    if (existing && await isProcessRunning(existing.pid)) {
-      announce(`Guard is already running (PID ${existing.pid})
-
-  Use ${chalk7.yellow(`bgrun --stop ${guardName}`)} to stop it
-  Use ${chalk7.yellow(`bgrun --guard --force`)} to restart`, "BGR Guard");
-      return;
-    }
-    if (existing) {
-      if (await isProcessRunning(existing.pid)) {
-        await terminateProcess(existing.pid);
-      }
-      await retryDatabaseOperation(() => removeProcessByName(guardName));
-    }
-    const { resolve } = __require("path");
-    const scriptPath = resolve(process.argv[1]);
-    const spawnCommand = `bun run ${scriptPath} --_guard-loop`;
-    const command = `bgrun --_guard-loop`;
-    const stdoutPath = join4(bgrDir2, `${guardName}-out.txt`);
-    const stderrPath = join4(bgrDir2, `${guardName}-err.txt`);
-    await Bun.write(stdoutPath, "");
-    await Bun.write(stderrPath, "");
-    const newProcess = Bun.spawn(getShellCommand(spawnCommand), {
-      env: { ...Bun.env, BGR_STDOUT: stdoutPath, BGR_STDERR: stderrPath },
-      cwd: bgrDir2,
-      stdout: "ignore",
-      stderr: "ignore",
-      detached: true
-    });
-    newProcess.unref();
-    await sleep3(1000);
-    let actualPid = await findChildPid(newProcess.pid);
-    if (!await isProcessRunning(actualPid)) {
-      const { psExec: ps } = await Promise.resolve().then(() => (init_platform(), exports_platform));
-      const result = ps(`Get-CimInstance Win32_Process -Filter "Name='bun.exe'" | Where-Object { $_.CommandLine -match '_guard-loop' } | Sort-Object -Property CreationDate -Descending | Select-Object -First 1 -ExpandProperty ProcessId`, 3000);
-      const foundPid = parseInt(result.trim());
-      if (!isNaN(foundPid) && foundPid > 0)
-        actualPid = foundPid;
-    }
-    await retryDatabaseOperation(() => insertProcess({
-      pid: actualPid,
-      workdir: bgrDir2,
-      command,
-      name: guardName,
-      env: "BGR_KEEP_ALIVE=false",
-      configPath: "",
-      stdout_path: stdoutPath,
-      stderr_path: stderrPath
-    }));
-    const msg = dedent`
-      ${chalk7.bold("\uD83D\uDEE1\uFE0F  BGR Standalone Guard launched")}
-      ${chalk7.gray("\u2500".repeat(40))}
-
-        Monitors: All processes with BGR_KEEP_ALIVE=true
-        Also watches: bgr-dashboard (auto-restart if it dies)
-        Check interval: 30 seconds
-        Backoff: Exponential after 5 rapid crashes
-
-      ${chalk7.gray("\u2500".repeat(40))}
-        Process: ${chalk7.white(guardName)}  |  PID: ${chalk7.white(String(actualPid))}
-
-        ${chalk7.yellow(`bgrun ${guardName} --logs`)}    View guard logs
-        ${chalk7.yellow(`bgrun --stop ${guardName}`)}    Stop the guard
-    `;
-    announce(msg, "BGR Guard");
+  if (values.guard || values["guard-off"]) {
+    await handleGuardToggle(positionals[0], Boolean(values.guard));
     return;
   }
   if (values.version) {