bgrun 3.3.1

package/dist/index.js

@@ -0,0 +1,1580 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+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,
+  readFileTail: () => readFileTail,
+  killProcessOnPort: () => killProcessOnPort,
+  isWindows: () => isWindows,
+  isProcessRunning: () => isProcessRunning,
+  isPortFree: () => isPortFree,
+  getShellCommand: () => getShellCommand,
+  getProcessPorts: () => getProcessPorts,
+  getProcessMemory: () => getProcessMemory,
+  getHomeDir: () => getHomeDir,
+  findPidByPort: () => findPidByPort,
+  findChildPid: () => findChildPid,
+  ensureDir: () => ensureDir,
+  copyFile: () => copyFile
+});
+import * as fs from "fs";
+import * as os from "os";
+var {$ } = globalThis.Bun;
+function isWindows() {
+  return process.platform === "win32";
+}
+function getHomeDir() {
+  return os.homedir();
+}
+async function isProcessRunning(pid, command) {
+  try {
+    if (command && (command.includes("docker run") || command.includes("docker-compose up") || command.includes("docker compose up"))) {
+      return await isDockerContainerRunning(command);
+    }
+    if (isWindows()) {
+      const result = await $`tasklist /FI "PID eq ${pid}" /NH`.nothrow().text();
+      return result.includes(`${pid}`);
+    } else {
+      const result = await $`ps -p ${pid}`.nothrow().text();
+      return result.includes(`${pid}`);
+    }
+  } catch {
+    return false;
+  }
+}
+async function isDockerContainerRunning(command) {
+  try {
+    const nameMatch = command.match(/--name\s+["']?(\S+?)["']?(?:\s|$)/);
+    if (nameMatch) {
+      const containerName = nameMatch[1];
+      const result = await $`docker inspect -f "{{.State.Running}}" ${containerName}`.nothrow().text();
+      return result.trim() === "true";
+    }
+    const imageMatch = command.match(/docker\s+run\s+.*?(?:-d\s+)?(\S+)\s*$/);
+    if (imageMatch) {
+      const imageName = imageMatch[1];
+      const result = await $`docker ps --filter ancestor=${imageName} --format "{{.ID}}"`.nothrow().text();
+      return result.trim().length > 0;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function getChildPids(pid) {
+  try {
+    if (isWindows()) {
+      const result = await $`wmic process where (ParentProcessId=${pid}) get ProcessId`.nothrow().text();
+      return result.split(`
+`).map((line) => parseInt(line.trim())).filter((n) => !isNaN(n) && n > 0);
+    } else {
+      const result = await $`ps --no-headers -o pid --ppid ${pid}`.nothrow().text();
+      return result.trim().split(`
+`).filter((p) => p.trim()).map((p) => parseInt(p)).filter((n) => !isNaN(n));
+    }
+  } catch {
+    return [];
+  }
+}
+async function terminateProcess(pid, force = false) {
+  const children = await getChildPids(pid);
+  for (const childPid of children) {
+    try {
+      if (isWindows()) {
+        if (force) {
+          await $`taskkill /F /PID ${childPid}`.nothrow().quiet();
+        } else {
+          await $`taskkill /PID ${childPid}`.nothrow().quiet();
+        }
+      } else {
+        const signal = force ? "KILL" : "TERM";
+        await $`kill -${signal} ${childPid}`.nothrow();
+      }
+    } catch {}
+  }
+  await Bun.sleep(500);
+  if (await isProcessRunning(pid)) {
+    try {
+      if (isWindows()) {
+        if (force) {
+          await $`taskkill /F /PID ${pid}`.nothrow().quiet();
+        } else {
+          await $`taskkill /PID ${pid}`.nothrow().quiet();
+        }
+      } else {
+        const signal = force ? "KILL" : "TERM";
+        await $`kill -${signal} ${pid}`.nothrow();
+      }
+    } catch {}
+  }
+}
+async function isPortFree(port) {
+  try {
+    if (isWindows()) {
+      const result = await $`netstat -ano | findstr :${port}`.nothrow().quiet().text();
+      for (const line of result.split(`
+`)) {
+        const match = line.match(new RegExp(`:(${port})\\s+.*LISTENING`));
+        if (match)
+          return false;
+      }
+      return true;
+    } else {
+      const result = await $`ss -tln sport = :${port}`.nothrow().quiet().text();
+      const lines = result.trim().split(`
+`).filter((l) => l.trim());
+      return lines.length <= 1;
+    }
+  } catch {
+    return true;
+  }
+}
+async function waitForPortFree(port, timeoutMs = 5000) {
+  const startTime = Date.now();
+  const pollInterval = 300;
+  while (Date.now() - startTime < timeoutMs) {
+    if (await isPortFree(port)) {
+      return true;
+    }
+    await Bun.sleep(pollInterval);
+  }
+  return false;
+}
+async function killProcessOnPort(port) {
+  try {
+    if (isWindows()) {
+      const result = await $`netstat -ano | findstr :${port}`.nothrow().quiet().text();
+      const pids = new Set;
+      for (const line of result.split(`
+`)) {
+        const match = line.match(new RegExp(`:(${port})\\s+.*?\\s+(\\d+)\\s*$`));
+        if (match && parseInt(match[1]) === port) {
+          const pid = parseInt(match[2]);
+          if (pid > 0)
+            pids.add(pid);
+        }
+      }
+      for (const pid of pids) {
+        await $`taskkill /F /T /PID ${pid}`.nothrow().quiet();
+        console.log(`Killed process ${pid} using port ${port}`);
+      }
+    } else {
+      const result = await $`lsof -ti :${port}`.nothrow().text();
+      if (result.trim()) {
+        const pids = result.trim().split(`
+`).filter((pid) => pid);
+        for (const pid of pids) {
+          await $`kill -9 ${pid}`.nothrow();
+          console.log(`Killed process ${pid} using port ${port}`);
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not check or kill process on port ${port}: ${error}`);
+  }
+}
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function getShellCommand(command) {
+  if (isWindows()) {
+    return ["cmd", "/c", command];
+  } else {
+    return ["sh", "-c", command];
+  }
+}
+async function findChildPid(parentPid) {
+  let currentPid = parentPid;
+  const maxDepth = 5;
+  for (let depth = 0;depth < maxDepth; depth++) {
+    try {
+      let childPids = [];
+      if (isWindows()) {
+        const result = await $`powershell -Command "Get-CimInstance Win32_Process -Filter 'ParentProcessId=${currentPid}' | Select-Object -ExpandProperty ProcessId"`.nothrow().text();
+        childPids = result.split(`
+`).map((line) => parseInt(line.trim())).filter((n) => !isNaN(n) && n > 0);
+      } else {
+        const result = await $`ps --no-headers -o pid --ppid ${currentPid}`.nothrow().text();
+        childPids = result.trim().split(`
+`).map((line) => parseInt(line.trim())).filter((n) => !isNaN(n) && n > 0);
+      }
+      if (childPids.length === 0) {
+        break;
+      }
+      currentPid = childPids[0];
+    } catch {
+      break;
+    }
+  }
+  return currentPid;
+}
+async function findPidByPort(port, maxWaitMs = 8000) {
+  const start = Date.now();
+  const pollMs = 500;
+  while (Date.now() - start < maxWaitMs) {
+    try {
+      if (isWindows()) {
+        const result = await $`netstat -ano`.nothrow().quiet().text();
+        for (const line of result.split(`
+`)) {
+          if (line.includes(`:${port}`) && line.includes("LISTENING")) {
+            const parts = line.trim().split(/\s+/);
+            const pid = parseInt(parts[parts.length - 1]);
+            if (!isNaN(pid) && pid > 0)
+              return pid;
+          }
+        }
+      } else {
+        try {
+          const result2 = await $`ss -tlnp`.nothrow().quiet().text();
+          for (const line of result2.split(`
+`)) {
+            if (line.includes(`:${port}`)) {
+              const pidMatch = line.match(/pid=(\d+)/);
+              if (pidMatch)
+                return parseInt(pidMatch[1]);
+            }
+          }
+        } catch {}
+        const result = await $`lsof -iTCP:${port} -sTCP:LISTEN -t`.nothrow().quiet().text();
+        const pid = parseInt(result.trim());
+        if (!isNaN(pid) && pid > 0)
+          return pid;
+      }
+    } catch {}
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+  return null;
+}
+async function readFileTail(filePath, lines) {
+  try {
+    const content = await Bun.file(filePath).text();
+    if (!lines) {
+      return content;
+    }
+    const allLines = content.split(/\r?\n/);
+    const tailLines = allLines.slice(-lines);
+    return tailLines.join(`
+`);
+  } catch (error) {
+    throw new Error(`Error reading file: ${error}`);
+  }
+}
+function copyFile(src, dest) {
+  fs.copyFileSync(src, dest);
+}
+async function getProcessMemory(pid) {
+  try {
+    if (isWindows()) {
+      const result = await $`wmic process where ProcessId=${pid} get WorkingSetSize`.nothrow().text();
+      const lines = result.split(`
+`).filter((line) => line.trim() && !line.includes("WorkingSetSize"));
+      if (lines.length > 0) {
+        return parseInt(lines[0].trim()) || 0;
+      }
+      return 0;
+    } else {
+      const result = await $`ps -o rss= -p ${pid}`.text();
+      const memoryKB = parseInt(result.trim());
+      return memoryKB * 1024;
+    }
+  } catch {
+    return 0;
+  }
+}
+async function getProcessPorts(pid) {
+  try {
+    if (isWindows()) {
+      const result = await $`netstat -ano`.nothrow().quiet().text();
+      const ports = new Set;
+      for (const line of result.split(`
+`)) {
+        const match = line.match(/^\s*TCP\s+\S+:(\d+)\s+\S+\s+LISTENING\s+(\d+)/);
+        if (match && parseInt(match[2]) === pid) {
+          ports.add(parseInt(match[1]));
+        }
+      }
+      return Array.from(ports);
+    } else {
+      try {
+        const result2 = await $`ss -tlnp`.nothrow().quiet().text();
+        const ports2 = new Set;
+        for (const line of result2.split(`
+`)) {
+          if (line.includes(`pid=${pid}`)) {
+            const portMatch = line.match(/:(\d+)\s/);
+            if (portMatch) {
+              ports2.add(parseInt(portMatch[1]));
+            }
+          }
+        }
+        if (ports2.size > 0)
+          return Array.from(ports2);
+      } catch {}
+      const result = await $`lsof -i -P -n -p ${pid}`.nothrow().quiet().text();
+      const ports = new Set;
+      for (const line of result.split(`
+`)) {
+        if (line.includes("LISTEN")) {
+          const portMatch = line.match(/:(\d+)\s+\(LISTEN\)/);
+          if (portMatch) {
+            ports.add(parseInt(portMatch[1]));
+          }
+        }
+      }
+      return Array.from(ports);
+    }
+  } catch {
+    return [];
+  }
+}
+var init_platform = () => {};
+
+// src/index.ts
+import { parseArgs } from "util";
+
+// src/utils.ts
+init_platform();
+import * as fs2 from "fs";
+import { join } from "path";
+import chalk from "chalk";
+function parseEnvString(envString) {
+  const env = {};
+  envString.split(",").forEach((pair) => {
+    const [key, value] = pair.split("=");
+    if (key && value)
+      env[key] = value;
+  });
+  return env;
+}
+function calculateRuntime(startTime) {
+  const start = new Date(startTime).getTime();
+  const now = new Date().getTime();
+  const diffInMinutes = Math.floor((now - start) / (1000 * 60));
+  return `${diffInMinutes} minutes`;
+}
+async function getVersion() {
+  try {
+    const pkgPath = join(import.meta.dir, "../package.json");
+    const pkg = await Bun.file(pkgPath).json();
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function validateDirectory(directory) {
+  if (!directory || !fs2.existsSync(directory)) {
+    console.log(chalk.red("\u274C Error: 'directory' must be a valid path."));
+    process.exit(1);
+  }
+}
+function tailFile(path, prefix, colorFn, lines) {
+  let position = 0;
+  let lastPartial = "";
+  if (!fs2.existsSync(path)) {
+    return () => {};
+  }
+  const fd = fs2.openSync(path, "r");
+  const printNewContent = () => {
+    try {
+      const stats = fs2.statSync(path);
+      if (stats.size <= position)
+        return;
+      const buffer = Buffer.alloc(stats.size - position);
+      fs2.readSync(fd, buffer, 0, buffer.length, position);
+      let content = buffer.toString();
+      content = lastPartial + content;
+      lastPartial = "";
+      const lineArray = content.split(/\r?\n/);
+      if (!content.endsWith(`
+`)) {
+        lastPartial = lineArray.pop() || "";
+      }
+      lineArray.forEach((line) => {
+        if (line) {
+          console.log(colorFn(prefix + line));
+        }
+      });
+      position = stats.size;
+    } catch (e) {}
+  };
+  const watcher = fs2.watch(path, { persistent: true }, (event) => {
+    if (event === "change") {
+      printNewContent();
+    }
+  });
+  printNewContent();
+  return () => {
+    watcher.close();
+    try {
+      fs2.closeSync(fd);
+    } catch {}
+  };
+}
+
+// src/db.ts
+init_platform();
+import { Database, z } from "sqlite-zod-orm";
+import { join as join2 } from "path";
+var {sleep } = globalThis.Bun;
+var ProcessSchema = z.object({
+  pid: z.number(),
+  workdir: z.string(),
+  command: z.string(),
+  name: z.string(),
+  env: z.string(),
+  configPath: z.string().default(""),
+  stdout_path: z.string(),
+  stderr_path: z.string(),
+  timestamp: z.string().default(() => new Date().toISOString())
+});
+var homePath = getHomeDir();
+var dbName = process.env.DB_NAME ?? "bgr";
+var dbPath = join2(homePath, ".bgr", `${dbName}_v2.sqlite`);
+ensureDir(join2(homePath, ".bgr"));
+var db = new Database(dbPath, {
+  process: ProcessSchema
+}, {
+  indexes: {
+    process: ["name", "timestamp", "pid"]
+  }
+});
+function getProcess(name) {
+  return db.process.select().where({ name }).orderBy("timestamp", "desc").limit(1).get() || null;
+}
+function getAllProcesses() {
+  return db.process.select().all();
+}
+function insertProcess(data) {
+  return db.process.insert({
+    ...data,
+    timestamp: new Date().toISOString()
+  });
+}
+function removeProcess(pid) {
+  const matches = db.process.select().where({ pid }).all();
+  for (const p of matches) {
+    db.process.delete(p.id);
+  }
+}
+function removeProcessByName(name) {
+  const matches = db.process.select().where({ name }).all();
+  for (const p of matches) {
+    db.process.delete(p.id);
+  }
+}
+function removeAllProcesses() {
+  const all = db.process.select().all();
+  for (const p of all) {
+    db.process.delete(p.id);
+  }
+}
+async function retryDatabaseOperation(operation, maxRetries = 5, delay = 100) {
+  for (let attempt = 1;attempt <= maxRetries; attempt++) {
+    try {
+      return operation();
+    } catch (err) {
+      if (err?.code === "SQLITE_BUSY" && attempt < maxRetries) {
+        await sleep(delay * attempt);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error("Max retries reached for database operation");
+}
+
+// src/commands/run.ts
+init_platform();
+
+// src/logger.ts
+import boxen from "boxen";
+import chalk2 from "chalk";
+function announce(message, title) {
+  console.log(boxen(chalk2.white(message), {
+    padding: 1,
+    margin: 1,
+    borderColor: "green",
+    title: title || "bgrun",
+    titleAlignment: "center",
+    borderStyle: "round"
+  }));
+}
+function error(message) {
+  console.error(boxen(chalk2.red(message), {
+    padding: 1,
+    margin: 1,
+    borderColor: "red",
+    title: "Error",
+    titleAlignment: "center",
+    borderStyle: "double"
+  }));
+  process.exit(1);
+}
+
+// src/config.ts
+function formatEnvKey(key) {
+  return key.toUpperCase().replace(/\./g, "_");
+}
+function flattenConfig(obj, prefix = "") {
+  return Object.keys(obj).reduce((acc, key) => {
+    const value = obj[key];
+    const newPrefix = prefix ? `${prefix}.${key}` : key;
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        const indexedPrefix = `${newPrefix}.${index}`;
+        if (typeof item === "object" && item !== null) {
+          Object.assign(acc, flattenConfig(item, indexedPrefix));
+        } else {
+          acc[formatEnvKey(indexedPrefix)] = String(item);
+        }
+      });
+    } else if (typeof value === "object" && value !== null) {
+      Object.assign(acc, flattenConfig(value, newPrefix));
+    } else {
+      acc[formatEnvKey(newPrefix)] = String(value);
+    }
+    return acc;
+  }, {});
+}
+async function parseConfigFile(configPath) {
+  const importPath = `${configPath}?t=${Date.now()}`;
+  const parsedConfig = await import(importPath).then((m) => m.default);
+  return flattenConfig(parsedConfig);
+}
+
+// src/commands/run.ts
+var {$: $2 } = globalThis.Bun;
+var {sleep: sleep2 } = globalThis.Bun;
+import { join as join3 } from "path";
+var homePath2 = getHomeDir();
+async function handleRun(options) {
+  const { command, directory, env, name, configPath, force, fetch, stdout, stderr } = options;
+  const existingProcess = name ? getProcess(name) : null;
+  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.`);
+      }
+      try {
+        await $2`git fetch origin`;
+        const localHash = (await $2`git rev-parse HEAD`.text()).trim();
+        const remoteHash = (await $2`git rev-parse origin/$(git rev-parse --abbrev-ref HEAD)`.text()).trim();
+        if (localHash !== remoteHash) {
+          await $2`git pull origin $(git rev-parse --abbrev-ref HEAD)`;
+          announce("\uD83D\uDCE5 Pulled latest changes", "Git Update");
+        }
+      } catch (err) {
+        error(`Failed to pull latest changes: ${err}`);
+      }
+    }
+    const isRunning = await isProcessRunning(existingProcess.pid);
+    if (isRunning && !force) {
+      error(`Process '${name}' is currently running. Use --force to restart.`);
+    }
+    let detectedPorts = [];
+    if (isRunning) {
+      detectedPorts = await getProcessPorts(existingProcess.pid);
+    }
+    if (isRunning) {
+      await terminateProcess(existingProcess.pid);
+      announce(`\uD83D\uDD25 Terminated existing process '${name}'`, "Process Terminated");
+    }
+    for (const port of detectedPorts) {
+      await killProcessOnPort(port);
+    }
+    for (const port of detectedPorts) {
+      const freed = await waitForPortFree(port, 5000);
+      if (!freed) {
+        await killProcessOnPort(port);
+        await waitForPortFree(port, 3000);
+      }
+    }
+    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) : {});
+  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()) {
+      try {
+        const newConfigEnv = await parseConfigFile(fullConfigPath);
+        finalEnv = { ...finalEnv, ...newConfigEnv };
+        console.log(`Loaded config from ${finalConfigPath}`);
+      } catch (err) {
+        console.warn(`Warning: Failed to parse config file ${finalConfigPath}: ${err.message}`);
+      }
+    } 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 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 actualPid = await findChildPid(newProcess.pid);
+  await sleep2(400);
+  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");
+}
+
+// src/commands/list.ts
+import chalk4 from "chalk";
+
+// src/table.ts
+import chalk3 from "chalk";
+function getTerminalWidth() {
+  return process.stdout.columns || 120;
+}
+function stripAnsi(str) {
+  return str.replace(/\u001b\[[0-9;]*m/g, "");
+}
+function truncateString(str, maxLength) {
+  const stripped = stripAnsi(str);
+  if (stripped.length <= maxLength)
+    return str;
+  const ellipsis = "\u2026";
+  if (maxLength < 1)
+    return "";
+  if (maxLength === 1)
+    return ellipsis;
+  const targetLength = maxLength - ellipsis.length;
+  return str.substring(0, targetLength > 0 ? targetLength : 0) + ellipsis;
+}
+function truncatePath(str, maxLength) {
+  const stripped = stripAnsi(str);
+  if (stripped.length <= maxLength)
+    return str;
+  const ellipsis = "\u2026";
+  if (maxLength < 3)
+    return truncateString(str, maxLength);
+  const targetLength = maxLength - ellipsis.length;
+  const startLen = Math.ceil(targetLength / 2);
+  const endLen = Math.floor(targetLength / 2);
+  return str.substring(0, startLen) + ellipsis + str.substring(str.length - endLen);
+}
+function calculateColumnWidths(rows, columns, maxWidth, padding = 2) {
+  const separatorsWidth = columns.length + 1;
+  const paddingWidth = padding * columns.length;
+  const availableWidth = maxWidth - separatorsWidth - paddingWidth;
+  const naturalWidths = new Map;
+  for (const col of columns) {
+    let maxNatural = stripAnsi(col.header).length;
+    for (const row of rows) {
+      const value = col.formatter ? col.formatter(row[col.key]) : String(row[col.key] || "");
+      maxNatural = Math.max(maxNatural, stripAnsi(value).length);
+    }
+    naturalWidths.set(col.key, maxNatural);
+  }
+  const totalNaturalWidth = Array.from(naturalWidths.values()).reduce((sum, w) => sum + w, 0);
+  if (totalNaturalWidth <= availableWidth) {
+    return naturalWidths;
+  }
+  let overage = totalNaturalWidth - availableWidth;
+  const currentWidths = new Map(naturalWidths);
+  while (overage > 0) {
+    let widestColKey = null;
+    let maxW = -1;
+    for (const [key, width] of currentWidths.entries()) {
+      if (width > maxW) {
+        maxW = width;
+        widestColKey = key;
+      }
+    }
+    if (widestColKey === null || maxW <= 1) {
+      break;
+    }
+    currentWidths.set(widestColKey, maxW - 1);
+    overage--;
+  }
+  return currentWidths;
+}
+function renderBorder(widths, padding, style) {
+  const [left, mid, right, line] = style;
+  let lineStr = left;
+  for (let i = 0;i < widths.length; i++) {
+    lineStr += line.repeat(widths[i] + padding);
+    if (i < widths.length - 1) {
+      lineStr += mid;
+    }
+  }
+  lineStr += right;
+  return lineStr;
+}
+function renderHorizontalTable(rows, columns, options = {}) {
+  const { maxWidth = getTerminalWidth(), padding = 2, borderStyle = "rounded", showHeaders = true } = options;
+  if (rows.length === 0)
+    return { table: chalk3.gray("No data to display"), truncatedIndices: [] };
+  const borderChars = {
+    rounded: ["\u256D", "\u252C", "\u256E", "\u2500", "\u2502", "\u251C", "\u253C", "\u2524", "\u2570", "\u2534", "\u256F"],
+    none: [" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "]
+  }[borderStyle];
+  const [tl, tc, tr, h, v, ml, mc, mr, bl, bc, br] = borderChars;
+  const columnWidths = calculateColumnWidths(rows, columns, maxWidth, padding);
+  const widthArray = columns.map((col) => columnWidths.get(col.key));
+  const truncatedIndices = new Set;
+  const lines = [];
+  const cellPadding = " ".repeat(padding / 2);
+  if (borderStyle !== "none")
+    lines.push(renderBorder(widthArray, padding, [tl, tc, tr, h]));
+  if (showHeaders) {
+    const headerCells = columns.map((col, i) => chalk3.bold(truncateString(col.header, widthArray[i]).padEnd(widthArray[i])));
+    lines.push(`${v}${cellPadding}${headerCells.join(`${cellPadding}${v}${cellPadding}`)}${cellPadding}${v}`);
+    if (borderStyle !== "none")
+      lines.push(renderBorder(widthArray, padding, [ml, mc, mr, h]));
+  }
+  rows.forEach((row, rowIndex) => {
+    const cells = columns.map((col, i) => {
+      const width = widthArray[i];
+      const originalValue = col.formatter ? col.formatter(row[col.key]) : String(row[col.key] || "");
+      if (stripAnsi(originalValue).length > width) {
+        truncatedIndices.add(rowIndex);
+      }
+      const truncator = col.truncator || truncateString;
+      const truncated = truncator(originalValue, width);
+      return truncated + " ".repeat(Math.max(0, width - stripAnsi(truncated).length));
+    });
+    lines.push(`${v}${cellPadding}${cells.join(`${cellPadding}${v}${cellPadding}`)}${cellPadding}${v}`);
+  });
+  if (borderStyle !== "none")
+    lines.push(renderBorder(widthArray, padding, [bl, bc, br, h]));
+  return { table: lines.join(`
+`), truncatedIndices: Array.from(truncatedIndices) };
+}
+function renderVerticalTree(rows, columns) {
+  const lines = [];
+  rows.forEach((row, index) => {
+    if (index > 0)
+      lines.push("");
+    const name = row.name ? `'${row.name}'` : `(ID: ${row.id})`;
+    lines.push(chalk3.cyan(`\u25B6 ${name}`));
+    columns.forEach((col) => {
+      const value = col.formatter ? col.formatter(row[col.key]) : String(row[col.key] || "");
+      lines.push(`  \u251C\u2500 ${chalk3.gray(`${col.header}:`)} ${value}`);
+    });
+  });
+  return lines.join(`
+`);
+}
+function renderHybridTable(rows, columns, options = {}) {
+  const { table, truncatedIndices } = renderHorizontalTable(rows, columns, options);
+  const output = [table];
+  if (truncatedIndices.length > 0) {
+    const truncatedRows = truncatedIndices.map((i) => rows[i]);
+    output.push(`
+` + renderVerticalTree(truncatedRows, columns));
+  }
+  return output.join(`
+`);
+}
+function renderProcessTable(processes, options) {
+  const columns = [
+    { key: "id", header: "ID", formatter: (id) => chalk3.blue(id) },
+    { key: "pid", header: "PID", formatter: (pid) => chalk3.yellow(pid) },
+    { key: "name", header: "Name", formatter: (name) => chalk3.cyan.bold(name) },
+    { key: "port", header: "Port", formatter: (port) => port === "-" ? chalk3.gray(port) : chalk3.hex("#FF6B6B")(port) },
+    { key: "command", header: "Command" },
+    { key: "workdir", header: "Directory", formatter: (dir) => chalk3.gray(dir), truncator: truncatePath },
+    { key: "status", header: "Status" },
+    { key: "runtime", header: "Runtime", formatter: (runtime) => chalk3.magenta(runtime) }
+  ];
+  return renderHybridTable(processes, columns, options);
+}
+
+// src/commands/list.ts
+init_platform();
+async function showAll(opts) {
+  const processes = getAllProcesses();
+  const filtered = processes.filter((proc) => {
+    if (!opts?.filter)
+      return true;
+    const envVars = parseEnvString(proc.env);
+    return envVars["BGR_GROUP"] === opts.filter;
+  });
+  if (opts?.json) {
+    const jsonData = [];
+    for (const proc of filtered) {
+      const isRunning = await isProcessRunning(proc.pid, proc.command);
+      const envVars = parseEnvString(proc.env);
+      const ports = isRunning ? await getProcessPorts(proc.pid) : [];
+      jsonData.push({
+        pid: proc.pid,
+        name: proc.name,
+        ports: ports.length > 0 ? ports : undefined,
+        status: isRunning ? "running" : "stopped",
+        env: envVars
+      });
+    }
+    console.log(JSON.stringify(jsonData, null, 2));
+    return;
+  }
+  const tableData = [];
+  for (const proc of filtered) {
+    const isRunning = await isProcessRunning(proc.pid, proc.command);
+    const runtime = calculateRuntime(proc.timestamp);
+    const ports = isRunning ? await getProcessPorts(proc.pid) : [];
+    tableData.push({
+      id: proc.id,
+      pid: proc.pid,
+      name: proc.name,
+      port: ports.length > 0 ? ports.map((p) => `:${p}`).join(",") : "-",
+      command: proc.command,
+      workdir: proc.workdir,
+      status: isRunning ? chalk4.green.bold("\u25CF Running") : chalk4.red.bold("\u25CB Stopped"),
+      runtime
+    });
+  }
+  if (tableData.length === 0) {
+    if (opts?.filter) {
+      announce(`No processes matched filter BGR_GROUP='${opts.filter}'.`, "No Matches");
+    } else {
+      announce("No processes found.", "Empty");
+    }
+    return;
+  }
+  const tableOutput = renderProcessTable(tableData, {
+    padding: 1,
+    borderStyle: "rounded",
+    showHeaders: true
+  });
+  console.log(tableOutput);
+  const runningCount = tableData.filter((p) => p.status.includes("Running")).length;
+  const stoppedCount = tableData.filter((p) => p.status.includes("Stopped")).length;
+  console.log(chalk4.cyan(`Total: ${tableData.length} processes (${chalk4.green(`${runningCount} running`)}, ${chalk4.red(`${stoppedCount} stopped`)})`));
+}
+
+// src/commands/cleanup.ts
+init_platform();
+import * as fs3 from "fs";
+async function handleDelete(name) {
+  const process2 = getProcess(name);
+  if (!process2) {
+    error(`No process found named '${name}'`);
+    return;
+  }
+  const isRunning = await isProcessRunning(process2.pid);
+  if (isRunning) {
+    await terminateProcess(process2.pid);
+  }
+  if (fs3.existsSync(process2.stdout_path)) {
+    try {
+      fs3.unlinkSync(process2.stdout_path);
+    } catch {}
+  }
+  if (fs3.existsSync(process2.stderr_path)) {
+    try {
+      fs3.unlinkSync(process2.stderr_path);
+    } catch {}
+  }
+  removeProcessByName(name);
+  announce(`Process '${name}' has been ${isRunning ? "stopped and " : ""}deleted`, "Process Deleted");
+}
+async function handleClean() {
+  const processes = getAllProcesses();
+  let cleanedCount = 0;
+  let deletedLogs = 0;
+  for (const proc of processes) {
+    const running = await isProcessRunning(proc.pid);
+    if (!running) {
+      removeProcess(proc.pid);
+      cleanedCount++;
+      if (fs3.existsSync(proc.stdout_path)) {
+        try {
+          fs3.unlinkSync(proc.stdout_path);
+          deletedLogs++;
+        } catch {}
+      }
+      if (fs3.existsSync(proc.stderr_path)) {
+        try {
+          fs3.unlinkSync(proc.stderr_path);
+          deletedLogs++;
+        } catch {}
+      }
+    }
+  }
+  if (cleanedCount === 0) {
+    announce("No stopped processes found to clean.", "Clean Complete");
+  } else {
+    announce(`Cleaned ${cleanedCount} stopped ${cleanedCount === 1 ? "process" : "processes"} and removed ${deletedLogs} log ${deletedLogs === 1 ? "file" : "files"}.`, "Clean Complete");
+  }
+}
+async function handleStop(name) {
+  const proc = getProcess(name);
+  if (!proc) {
+    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 { getProcessPorts: getProcessPorts2, killProcessOnPort: killProcessOnPort2 } = await Promise.resolve().then(() => (init_platform(), exports_platform));
+  const ports = await getProcessPorts2(proc.pid);
+  await terminateProcess(proc.pid);
+  for (const port of ports) {
+    await killProcessOnPort2(port);
+  }
+  announce(`Process '${name}' has been stopped (kept in registry).`, "Process Stopped");
+}
+async function handleDeleteAll() {
+  const processes = getAllProcesses();
+  if (processes.length === 0) {
+    announce("There are no processes to delete.", "Delete All");
+    return;
+  }
+  const { getProcessPorts: getProcessPorts2, killProcessOnPort: killProcessOnPort2, waitForPortFree: waitForPortFree2 } = await Promise.resolve().then(() => (init_platform(), exports_platform));
+  let killedCount = 0;
+  let portsFreed = 0;
+  for (const proc of processes) {
+    const running = await isProcessRunning(proc.pid);
+    if (running) {
+      const ports = await getProcessPorts2(proc.pid);
+      await terminateProcess(proc.pid, true);
+      killedCount++;
+      for (const port of ports) {
+        await killProcessOnPort2(port);
+        const freed = await waitForPortFree2(port, 3000);
+        if (!freed) {
+          await killProcessOnPort2(port);
+          await waitForPortFree2(port, 2000);
+        }
+        portsFreed++;
+      }
+    }
+    if (fs3.existsSync(proc.stdout_path)) {
+      try {
+        fs3.unlinkSync(proc.stdout_path);
+      } catch {}
+    }
+    if (fs3.existsSync(proc.stderr_path)) {
+      try {
+        fs3.unlinkSync(proc.stderr_path);
+      } catch {}
+    }
+  }
+  removeAllProcesses();
+  const parts = [`${processes.length} ${processes.length === 1 ? "process" : "processes"} deleted`];
+  if (killedCount > 0)
+    parts.push(`${killedCount} force-killed`);
+  if (portsFreed > 0)
+    parts.push(`${portsFreed} ${portsFreed === 1 ? "port" : "ports"} freed`);
+  announce(parts.join(", ") + ".", "Nuke Complete");
+}
+
+// src/commands/watch.ts
+init_platform();
+import * as fs4 from "fs";
+import { join as join4 } from "path";
+import path from "path";
+import chalk5 from "chalk";
+async function handleWatch(options, logOptions) {
+  let currentProcess = null;
+  let isRestarting = false;
+  let debounceTimeout = null;
+  let tailStops = [];
+  let lastRestartPath = null;
+  const dumpLogsIfDead = async (proc, reason) => {
+    const isDead = !await isProcessRunning(proc.pid);
+    if (!isDead)
+      return false;
+    console.log(chalk5.yellow(`\uD83D\uDC80 Process '${options.name}' died immediately after ${reason}\u2014dumping logs:`));
+    const readAndDump = (path2, color, label) => {
+      try {
+        if (fs4.existsSync(path2)) {
+          const content = fs4.readFileSync(path2, "utf8").trim();
+          if (content) {
+            console.log(`${color.bold(label)}:
+${color(content)}
+`);
+          } else {
+            console.log(`${color(label)}: (empty)`);
+          }
+        }
+      } catch (err) {
+        console.warn(chalk5.gray(`Could not read ${label} log: ${err}`));
+      }
+    };
+    if (logOptions.logType === "both" || logOptions.logType === "stdout") {
+      readAndDump(proc.stdout_path, chalk5.white, "\uD83D\uDCC4 Stdout");
+    }
+    if (logOptions.logType === "both" || logOptions.logType === "stderr") {
+      readAndDump(proc.stderr_path, chalk5.red, "\uD83D\uDCC4 Stderr");
+    }
+    return true;
+  };
+  const waitForLogReady = (logPath, timeoutMs = 5000) => {
+    return new Promise((resolve, reject) => {
+      const checkReady = () => {
+        try {
+          if (fs4.existsSync(logPath)) {
+            const stat = fs4.statSync(logPath);
+            if (stat.size > 0) {
+              return true;
+            }
+          }
+        } catch {}
+        return false;
+      };
+      if (checkReady()) {
+        resolve();
+        return;
+      }
+      const dir = path.dirname(logPath);
+      const filename = path.basename(logPath);
+      const watcher2 = fs4.watch(dir, (eventType, changedFilename) => {
+        if (changedFilename === filename && eventType === "change") {
+          if (checkReady()) {
+            watcher2.close();
+            resolve();
+          }
+        }
+      });
+      setTimeout(() => {
+        watcher2.close();
+        reject(new Error(`Log file ${logPath} did not become ready within ${timeoutMs}ms`));
+      }, timeoutMs);
+    });
+  };
+  const startTails = async () => {
+    const stops = [];
+    if (!logOptions.showLogs || !currentProcess)
+      return stops;
+    console.log(chalk5.gray(`
+` + "\u2500".repeat(50) + `
+`));
+    if (logOptions.logType === "both" || logOptions.logType === "stdout") {
+      console.log(chalk5.green.bold(`\uD83D\uDCC4 Tailing stdout for ${options.name}:`));
+      console.log(chalk5.gray("\u2550".repeat(50)));
+      try {
+        await waitForLogReady(currentProcess.stdout_path);
+      } catch (err) {
+        console.warn(chalk5.yellow(`\u26A0\uFE0F  Stdout log not ready yet for ${options.name}\u2014starting tail anyway: ${err.message}`));
+      }
+      const stop = tailFile(currentProcess.stdout_path, "", chalk5.white, logOptions.lines);
+      stops.push(stop);
+    }
+    if (logOptions.logType === "both" || logOptions.logType === "stderr") {
+      console.log(chalk5.red.bold(`\uD83D\uDCC4 Tailing stderr for ${options.name}:`));
+      console.log(chalk5.gray("\u2550".repeat(50)));
+      try {
+        await waitForLogReady(currentProcess.stderr_path);
+      } catch (err) {
+        console.warn(chalk5.yellow(`\u26A0\uFE0F  Stderr log not ready yet for ${options.name}\u2014starting tail anyway: ${err.message}`));
+      }
+      const stop = tailFile(currentProcess.stderr_path, "", chalk5.red, logOptions.lines);
+      stops.push(stop);
+    }
+    return stops;
+  };
+  const restartProcess = async (path2) => {
+    if (isRestarting)
+      return;
+    isRestarting = true;
+    const restartReason = path2 ? `restart (change in ${path2})` : "initial start";
+    lastRestartPath = path2 || null;
+    tailStops.forEach((stop) => stop());
+    tailStops = [];
+    console.clear();
+    announce(`\uD83D\uDD04 Restarting process '${options.name}'... [${restartReason}]`, "Watch Mode");
+    try {
+      await handleRun({ ...options, force: true });
+      currentProcess = getProcess(options.name);
+      if (!currentProcess) {
+        error(`Failed to find process '${options.name}' after restart.`);
+        return;
+      }
+      const died = await dumpLogsIfDead(currentProcess, restartReason);
+      if (died) {
+        if (lastRestartPath) {
+          console.log(chalk5.yellow(`\u26A0\uFE0F  Compile error on change\u2014pausing restarts until manual fix.`));
+          return;
+        } else {
+          error(`Failed to start process '${options.name}'. Aborting watch mode.`);
+          return;
+        }
+      }
+      tailStops = await startTails();
+    } catch (err) {
+      error(`Error during restart: ${err}`);
+    } finally {
+      isRestarting = false;
+      if (currentProcess) {
+        console.log(chalk5.cyan(`
+\uD83D\uDC40 Watching for file changes in: ${currentProcess.workdir}`));
+      }
+    }
+  };
+  console.clear();
+  announce(`\uD83D\uDE80 Starting initial process '${options.name}' in watch mode...`, "Watch Mode");
+  await handleRun(options);
+  currentProcess = getProcess(options.name);
+  if (!currentProcess) {
+    error(`Could not start or find process '${options.name}'. Aborting watch mode.`);
+    return;
+  }
+  const initialDied = await dumpLogsIfDead(currentProcess, "initial start");
+  if (initialDied) {
+    error(`Failed to start process '${options.name}'. Aborting watch mode.`);
+    return;
+  }
+  tailStops = await startTails();
+  const workdir = currentProcess.workdir;
+  console.log(chalk5.cyan(`
+\uD83D\uDC40 Watching for file changes in: ${workdir}`));
+  const watcher = fs4.watch(workdir, { recursive: true }, (eventType, filename) => {
+    if (filename == null)
+      return;
+    const fullPath = join4(workdir, filename);
+    if (fullPath.includes(".git") || fullPath.includes("node_modules"))
+      return;
+    if (debounceTimeout)
+      clearTimeout(debounceTimeout);
+    debounceTimeout = setTimeout(() => restartProcess(fullPath), 500);
+  });
+  const cleanup = async () => {
+    console.log(chalk5.magenta(`
+SIGINT received...`));
+    watcher.close();
+    tailStops.forEach((stop) => stop());
+    if (debounceTimeout)
+      clearTimeout(debounceTimeout);
+    const procToKill = getProcess(options.name);
+    if (procToKill) {
+      const isRunning = await isProcessRunning(procToKill.pid);
+      if (isRunning) {
+        console.log(`process ${procToKill.name} (PID: ${procToKill.pid}) still running`);
+      }
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+
+// src/commands/logs.ts
+init_platform();
+import chalk6 from "chalk";
+import * as fs5 from "fs";
+async function showLogs(name, logType = "both", lines) {
+  const proc = getProcess(name);
+  if (!proc) {
+    error(`No process found named '${name}'`);
+    return;
+  }
+  if (logType === "both" || logType === "stdout") {
+    console.log(chalk6.green.bold(`\uD83D\uDCC4 Stdout logs for ${name}:`));
+    console.log(chalk6.gray("\u2550".repeat(50)));
+    if (fs5.existsSync(proc.stdout_path)) {
+      try {
+        const output = await readFileTail(proc.stdout_path, lines);
+        console.log(output || chalk6.gray("(no output)"));
+      } catch (err) {
+        console.log(chalk6.red(`Error reading stdout: ${err}`));
+      }
+    } else {
+      console.log(chalk6.gray("(log file not found)"));
+    }
+    if (logType === "both") {
+      console.log(`
+`);
+    }
+  }
+  if (logType === "both" || logType === "stderr") {
+    console.log(chalk6.red.bold(`\uD83D\uDCC4 Stderr logs for ${name}:`));
+    console.log(chalk6.gray("\u2550".repeat(50)));
+    if (fs5.existsSync(proc.stderr_path)) {
+      try {
+        const output = await readFileTail(proc.stderr_path, lines);
+        console.log(output || chalk6.gray("(no errors)"));
+      } catch (err) {
+        console.log(chalk6.red(`Error reading stderr: ${err}`));
+      }
+    } else {
+      console.log(chalk6.gray("(log file not found)"));
+    }
+  }
+}
+
+// src/commands/details.ts
+init_platform();
+import chalk7 from "chalk";
+async function showDetails(name) {
+  const proc = getProcess(name);
+  if (!proc) {
+    error(`No process found named '${name}'`);
+    return;
+  }
+  const isRunning = await isProcessRunning(proc.pid, proc.command);
+  const runtime = calculateRuntime(proc.timestamp);
+  const envVars = parseEnvString(proc.env);
+  const ports = isRunning ? await getProcessPorts(proc.pid) : [];
+  const portDisplay = ports.length > 0 ? ports.map((p) => chalk7.hex("#FF6B6B")(`:${p}`)).join(", ") : null;
+  const details = `
+${chalk7.bold("Process Details:")}
+${chalk7.gray("\u2550".repeat(50))}
+${chalk7.cyan.bold("Name:")} ${proc.name}
+${chalk7.yellow.bold("PID:")} ${proc.pid}${portDisplay ? `
+${chalk7.hex("#FF6B6B").bold("Port:")} ${portDisplay}` : ""}
+${chalk7.bold("Status:")} ${isRunning ? chalk7.green.bold("\u25CF Running") : chalk7.red.bold("\u25CB Stopped")}
+${chalk7.magenta.bold("Runtime:")} ${runtime}
+${chalk7.blue.bold("Working Directory:")} ${proc.workdir}
+${chalk7.white.bold("Command:")} ${proc.command}
+${chalk7.gray.bold("Config Path:")} ${proc.configPath}
+${chalk7.green.bold("Stdout Path:")} ${proc.stdout_path}
+${chalk7.red.bold("Stderr Path:")} ${proc.stderr_path}
+
+${chalk7.bold("\uD83D\uDD27 Environment Variables:")}
+${chalk7.gray("\u2550".repeat(50))}
+${Object.entries(envVars).map(([key, value]) => `${chalk7.cyan.bold(key)} = ${chalk7.yellow(value)}`).join(`
+`)}
+`;
+  announce(details, `Process Details: ${name}`);
+}
+
+// src/server.ts
+import { start } from "melina";
+import path2 from "path";
+async function startServer() {
+  const appDir = path2.join(import.meta.dir, "../dashboard/app");
+  const port = process.env.BUN_PORT ? parseInt(process.env.BUN_PORT, 10) : 3000;
+  await start({
+    appDir,
+    defaultTitle: "bgrun Dashboard - Process Manager",
+    globalCss: path2.join(appDir, "globals.css"),
+    port
+  });
+}
+
+// src/index.ts
+init_platform();
+import dedent from "dedent";
+import chalk8 from "chalk";
+import { join as join5 } from "path";
+var {sleep: sleep3 } = globalThis.Bun;
+async function showHelp() {
+  const usage = dedent`
+    ${chalk8.bold("bgrun \u2014 Bun Background Runner")}
+    ${chalk8.gray("\u2550".repeat(50))}
+
+    ${chalk8.yellow("Usage:")}
+      bgrun [name] [options]
+
+    ${chalk8.yellow("Commands:")}
+      bgrun                     List all processes
+      bgrun [name]             Show details for a process
+      bgrun --dashboard        Launch web dashboard (managed by bgrun)
+      bgrun --restart [name]   Restart a process
+      bgrun --stop [name]      Stop a process (keep in registry)
+      bgrun --delete [name]    Delete a process
+      bgrun --clean            Remove all stopped processes
+      bgrun --nuke             Delete ALL processes
+
+    ${chalk8.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)
+      --watch                Watch for file changes and auto-restart
+      --force                Force restart existing process
+      --fetch                Fetch latest git changes before running
+      --json                 Output in JSON format
+      --filter <group>       Filter list by BGR_GROUP
+      --logs                 Show logs
+      --log-stdout           Show only stdout logs
+      --log-stderr           Show only stderr logs
+      --lines <n>            Number of log lines to show (default: all)
+      --version              Show version
+      --dashboard            Launch web dashboard as bgrun-managed process
+      --port <number>        Port for dashboard (default: 3000)
+      --help                 Show this help message
+
+    ${chalk8.yellow("Examples:")}
+      bgrun --dashboard
+      bgrun --name myapp --command "bun run dev" --directory . --watch
+      bgrun myapp --logs --lines 50
+  `;
+  console.log(usage);
+}
+async function run() {
+  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" },
+      stop: { 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" },
+      _serve: { type: "boolean" },
+      port: { type: "string" }
+    },
+    strict: false,
+    allowPositionals: true
+  });
+  if (values["_serve"]) {
+    await startServer();
+    return;
+  }
+  if (values.dashboard) {
+    const dashboardName = "bgr-dashboard";
+    const homePath3 = getHomeDir();
+    const bgrDir = join5(homePath3, ".bgr");
+    const requestedPort = values.port;
+    const existing = getProcess(dashboardName);
+    if (existing && await isProcessRunning(existing.pid)) {
+      const existingPorts = await getProcessPorts(existing.pid);
+      const portStr = existingPorts.length > 0 ? `:${existingPorts[0]}` : "(detecting...)";
+      announce(`Dashboard is already running (PID ${existing.pid})
+
+` + `  \uD83C\uDF10  ${chalk8.cyan(`http://localhost${portStr}`)}
+
+` + `  Use ${chalk8.yellow(`bgrun --stop ${dashboardName}`)} to stop it
+` + `  Use ${chalk8.yellow(`bgrun --dashboard --force`)} to restart`, "BGR Dashboard");
+      return;
+    }
+    if (existing) {
+      if (await isProcessRunning(existing.pid)) {
+        const detectedPorts = await getProcessPorts(existing.pid);
+        await terminateProcess(existing.pid);
+        for (const p of detectedPorts) {
+          await killProcessOnPort(p);
+          await waitForPortFree(p, 5000);
+        }
+      }
+      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 = join5(bgrDir, `${dashboardName}-out.txt`);
+    const stderrPath = join5(bgrDir, `${dashboardName}-err.txt`);
+    await Bun.write(stdoutPath, "");
+    await Bun.write(stderrPath, "");
+    const spawnEnv = { ...Bun.env };
+    if (requestedPort) {
+      spawnEnv.BUN_PORT = requestedPort;
+    }
+    const newProcess = Bun.spawn(getShellCommand(spawnCommand), {
+      env: spawnEnv,
+      cwd: bgrDir,
+      stdout: Bun.file(stdoutPath),
+      stderr: Bun.file(stderrPath)
+    });
+    newProcess.unref();
+    await sleep3(2000);
+    const actualPid = await findChildPid(newProcess.pid);
+    let actualPort = null;
+    for (let attempt = 0;attempt < 10; attempt++) {
+      const ports = await getProcessPorts(actualPid);
+      if (ports.length > 0) {
+        actualPort = ports[0];
+        break;
+      }
+      await sleep3(1000);
+    }
+    await retryDatabaseOperation(() => insertProcess({
+      pid: actualPid,
+      workdir: bgrDir,
+      command,
+      name: dashboardName,
+      env: "",
+      configPath: "",
+      stdout_path: stdoutPath,
+      stderr_path: stderrPath
+    }));
+    const portDisplay = actualPort ? String(actualPort) : "(detecting...)";
+    const urlDisplay = actualPort ? `http://localhost:${actualPort}` : "http://localhost (port auto-assigned)";
+    const msg = dedent`
+      ${chalk8.bold("\u26A1 BGR Dashboard launched")}
+      ${chalk8.gray("\u2500".repeat(40))}
+
+        \u{1f310}  Open in browser: ${chalk8.cyan.underline(urlDisplay)}
+        \u{1f4ca}  Manage all your processes from the web UI
+        \u{1f504}  Auto-refreshes every 3 seconds
+
+      ${chalk8.gray("\u2500".repeat(40))}
+        Process: ${chalk8.white(dashboardName)}  |  PID: ${chalk8.white(String(actualPid))}  |  Port: ${chalk8.white(portDisplay)}
+
+        ${chalk8.yellow("bgrun bgr-dashboard --logs")}    View dashboard logs
+        ${chalk8.yellow("bgrun --stop bgr-dashboard")}    Stop the dashboard
+        ${chalk8.yellow("bgrun --restart bgr-dashboard")} Restart the dashboard
+    `;
+    announce(msg, "BGR Dashboard");
+    return;
+  }
+  if (values.version) {
+    console.log(`bgrun version: ${await getVersion()}`);
+    return;
+  }
+  if (values.help) {
+    await showHelp();
+    return;
+  }
+  if (values.nuke) {
+    await handleDeleteAll();
+    return;
+  }
+  if (values.clean) {
+    await handleClean();
+    return;
+  }
+  const name = values.name || positionals[0];
+  if (values.delete) {
+    if (name) {
+      await handleDelete(name);
+    } else {
+      error("Please specify a process name to delete.");
+    }
+    return;
+  }
+  if (values.restart) {
+    if (!name) {
+      error("Please specify a process name to restart.");
+    }
+    await handleRun({
+      action: "run",
+      name,
+      force: true,
+      remoteName: ""
+    });
+    return;
+  }
+  if (values.stop) {
+    if (!name) {
+      error("Please specify a process name to stop.");
+    }
+    await handleStop(name);
+    return;
+  }
+  if (values.logs || values["log-stdout"] || values["log-stderr"]) {
+    if (!name) {
+      error("Please specify a process name to show logs for.");
+    }
+    const logType = values["log-stdout"] ? "stdout" : values["log-stderr"] ? "stderr" : "both";
+    const lines = values.lines ? parseInt(values.lines) : undefined;
+    await showLogs(name, logType, lines);
+    return;
+  }
+  if (values.watch) {
+    await handleWatch({
+      action: "watch",
+      name,
+      command: values.command,
+      directory: values.directory,
+      configPath: values.config,
+      force: values.force,
+      remoteName: "",
+      dbPath: values.db,
+      stdout: values.stdout,
+      stderr: values.stderr
+    }, {
+      showLogs: values.logs || false,
+      logType: "both",
+      lines: values.lines ? parseInt(values.lines) : undefined
+    });
+    return;
+  }
+  if (name) {
+    if (!values.command && !values.directory) {
+      await showDetails(name);
+    } else {
+      await handleRun({
+        action: "run",
+        name,
+        command: values.command,
+        directory: values.directory,
+        configPath: values.config,
+        force: values.force,
+        fetch: values.fetch,
+        remoteName: "",
+        dbPath: values.db,
+        stdout: values.stdout,
+        stderr: values.stderr
+      });
+    }
+  } else {
+    if (values.command) {
+      error("Process name is required.");
+    }
+    await showAll({
+      json: values.json,
+      filter: values.filter
+    });
+  }
+}
+run().catch((err) => {
+  console.error(chalk8.red(err));
+  process.exit(1);
+});