bgrun 3.3.1

package/src/platform.ts

@@ -0,0 +1,440 @@
+/**
+ * Cross-platform utility functions for BGR
+ * Provides Windows and Unix compatible process management
+ */
+
+import * as fs from "fs";
+import * as os from "os";
+import { $ } from "bun";
+
+/** Detect if running on Windows - use function to prevent bundler tree-shaking */
+export function isWindows(): boolean {
+  return process.platform === "win32";
+}
+
+/**
+ * Get the user's home directory cross-platform
+ */
+export function getHomeDir(): string {
+  return os.homedir();
+}
+
+/**
+ * Check if a process with the given PID is running
+ * For Docker containers, checks container status instead of PID
+ */
+export async function isProcessRunning(pid: number, command?: string): Promise<boolean> {
+  try {
+    // Docker container detection
+    if (command && (command.includes('docker run') || command.includes('docker-compose up') || command.includes('docker compose up'))) {
+      return await isDockerContainerRunning(command);
+    }
+
+    if (isWindows()) {
+      // On Windows, use tasklist to check for PID
+      const result = await $`tasklist /FI "PID eq ${pid}" /NH`.nothrow().text();
+      return result.includes(`${pid}`);
+    } else {
+      // On Unix, use ps -p
+      const result = await $`ps -p ${pid}`.nothrow().text();
+      return result.includes(`${pid}`);
+    }
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a Docker container from a command is running
+ */
+async function isDockerContainerRunning(command: string): Promise<boolean> {
+  try {
+    // Extract container name from --name flag
+    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';
+    }
+
+    // If no --name, try to find running containers that match the image
+    // Extract image name (last argument before -d or after -d)
+    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;
+  }
+}
+
+
+/**
+ * Get child process PIDs (for termination)
+ */
+async function getChildPids(pid: number): Promise<number[]> {
+  try {
+    if (isWindows()) {
+      // On Windows, use wmic to get child processes
+      const result = await $`wmic process where (ParentProcessId=${pid}) get ProcessId`.nothrow().text();
+      return result
+        .split('\n')
+        .map(line => parseInt(line.trim()))
+        .filter(n => !isNaN(n) && n > 0);
+    } else {
+      // On Unix, use ps --ppid
+      const result = await $`ps --no-headers -o pid --ppid ${pid}`.nothrow().text();
+      return result
+        .trim()
+        .split('\n')
+        .filter(p => p.trim())
+        .map(p => parseInt(p))
+        .filter(n => !isNaN(n));
+    }
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Terminate a process and its children
+ */
+export async function terminateProcess(pid: number, force: boolean = false): Promise<void> {
+  // First, kill children
+  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 {
+      // Ignore errors for already-dead processes
+    }
+  }
+
+  // Wait a bit for graceful shutdown
+  await Bun.sleep(500);
+
+  // Then kill the parent if still running
+  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 {
+      // Ignore errors
+    }
+  }
+}
+
+/**
+ * Check if a port is free by attempting to bind to it.
+ */
+export async function isPortFree(port: number): Promise<boolean> {
+  try {
+    if (isWindows()) {
+      // On Windows, check netstat for anything LISTENING on this port
+      const result = await $`netstat -ano | findstr :${port}`.nothrow().quiet().text();
+      for (const line of result.split('\n')) {
+        // Only match exact port (avoid :35560 matching :3556)
+        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();
+      // If output has more than the header line, port is in use
+      const lines = result.trim().split('\n').filter(l => l.trim());
+      return lines.length <= 1;
+    }
+  } catch {
+    // If we can't check, assume it's free
+    return true;
+  }
+}
+
+/**
+ * Wait for a port to become free, polling with timeout.
+ * Returns true if port is free, false if timeout reached.
+ */
+export async function waitForPortFree(port: number, timeoutMs: number = 5000): Promise<boolean> {
+  const startTime = Date.now();
+  const pollInterval = 300;
+
+  while (Date.now() - startTime < timeoutMs) {
+    if (await isPortFree(port)) {
+      return true;
+    }
+    await Bun.sleep(pollInterval);
+  }
+  return false;
+}
+
+
+/**
+ * Kill processes using a specific port.
+ * Force-kills all processes bound to the port and verifies they're gone.
+ */
+export async function killProcessOnPort(port: number): Promise<void> {
+  try {
+    if (isWindows()) {
+      // On Windows, use netstat to find processes on port
+      const result = await $`netstat -ano | findstr :${port}`.nothrow().quiet().text();
+      const pids = new Set<number>();
+
+      for (const line of result.split('\n')) {
+        // Match exact port — avoid :35560 matching :3556
+        // Match any state (LISTENING, ESTABLISHED, TIME_WAIT, etc.)
+        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) {
+        // Force kill with /F /T (tree kill to get children too)
+        await $`taskkill /F /T /PID ${pid}`.nothrow().quiet();
+        console.log(`Killed process ${pid} using port ${port}`);
+      }
+    } else {
+      // On Unix, use lsof
+      const result = await $`lsof -ti :${port}`.nothrow().text();
+      if (result.trim()) {
+        const pids = result.trim().split('\n').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}`);
+  }
+}
+
+/**
+ * Ensure a directory exists, creating it if necessary
+ */
+export function ensureDir(dirPath: string): void {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+/**
+ * Get the shell command array for spawning a process
+ * On Windows uses cmd.exe, on Unix uses sh
+ */
+export function getShellCommand(command: string): string[] {
+  if (isWindows()) {
+    return ["cmd", "/c", command];
+  } else {
+    return ["sh", "-c", command];
+  }
+}
+
+/**
+ * Find the actual child process PID spawned by a shell wrapper.
+ * Traverses the process tree recursively to find the deepest (leaf) child.
+ * On Windows, bgr spawn creates: cmd.exe → bgr.exe → bun.exe
+ * We need the bun.exe PID, not the intermediate bgr.exe.
+ */
+export async function findChildPid(parentPid: number): Promise<number> {
+  let currentPid = parentPid;
+  const maxDepth = 5; // Safety limit to avoid infinite loops
+
+  for (let depth = 0; depth < maxDepth; depth++) {
+    try {
+      let childPids: number[] = [];
+
+      if (isWindows()) {
+        const result = await $`powershell -Command "Get-CimInstance Win32_Process -Filter 'ParentProcessId=${currentPid}' | Select-Object -ExpandProperty ProcessId"`.nothrow().text();
+        childPids = result
+          .split('\n')
+          .map((line: string) => parseInt(line.trim()))
+          .filter((n: number) => !isNaN(n) && n > 0);
+      } else {
+        const result = await $`ps --no-headers -o pid --ppid ${currentPid}`.nothrow().text();
+        childPids = result
+          .trim()
+          .split('\n')
+          .map(line => parseInt(line.trim()))
+          .filter(n => !isNaN(n) && n > 0);
+      }
+
+      if (childPids.length === 0) {
+        // No children — currentPid is the leaf process
+        break;
+      }
+
+      // Follow the first child deeper
+      currentPid = childPids[0];
+    } catch {
+      break;
+    }
+  }
+
+  return currentPid;
+}
+
+/**
+ * Wait for a port to become active and return the PID listening on it.
+ * More reliable than findChildPid since it waits for the actual server
+ * to bind the port rather than racing the process tree traversal.
+ */
+export async function findPidByPort(port: number, maxWaitMs = 8000): Promise<number | null> {
+  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('\n')) {
+          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 result = await $`ss -tlnp`.nothrow().quiet().text();
+          for (const line of result.split('\n')) {
+            if (line.includes(`:${port}`)) {
+              const pidMatch = line.match(/pid=(\d+)/);
+              if (pidMatch) return parseInt(pidMatch[1]);
+            }
+          }
+        } catch { /* ss not available, try lsof */ }
+
+        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 { /* retry */ }
+
+    await new Promise(resolve => setTimeout(resolve, pollMs));
+  }
+
+  return null;
+}
+
+export async function readFileTail(filePath: string, lines?: number): Promise<string> {
+  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('\n');
+  } catch (error) {
+    throw new Error(`Error reading file: ${error}`);
+  }
+}
+
+/**
+ * Copy a file from source to destination
+ */
+export function copyFile(src: string, dest: string): void {
+  fs.copyFileSync(src, dest);
+}
+
+/**
+ * Get memory usage of a process in bytes
+ */
+export async function getProcessMemory(pid: number): Promise<number> {
+  try {
+    if (isWindows()) {
+      // On Windows, use wmic to get memory
+      const result = await $`wmic process where ProcessId=${pid} get WorkingSetSize`.nothrow().text();
+      const lines = result.split('\n').filter(line => line.trim() && !line.includes('WorkingSetSize'));
+      if (lines.length > 0) {
+        return parseInt(lines[0].trim()) || 0;
+      }
+      return 0;
+    } else {
+      // On Unix, use ps to get RSS in KB
+      const result = await $`ps -o rss= -p ${pid}`.text();
+      const memoryKB = parseInt(result.trim());
+      return memoryKB * 1024; // Convert to bytes
+    }
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Get the TCP ports a process is currently listening on by querying the OS.
+ * Returns an array of port numbers (empty if none or process not found).
+ */
+export async function getProcessPorts(pid: number): Promise<number[]> {
+  try {
+    if (isWindows()) {
+      // netstat -ano lists all connections with PIDs
+      const result = await $`netstat -ano`.nothrow().quiet().text();
+      const ports = new Set<number>();
+      for (const line of result.split('\n')) {
+        // Match lines like: TCP    0.0.0.0:3556    0.0.0.0:0    LISTENING    8608
+        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 {
+      // Unix: use ss (modern) with fallback to lsof
+      try {
+        const result = await $`ss -tlnp`.nothrow().quiet().text();
+        const ports = new Set<number>();
+        for (const line of result.split('\n')) {
+          if (line.includes(`pid=${pid}`)) {
+            const portMatch = line.match(/:(\d+)\s/);
+            if (portMatch) {
+              ports.add(parseInt(portMatch[1]));
+            }
+          }
+        }
+        if (ports.size > 0) return Array.from(ports);
+      } catch { /* ss not available, try lsof */ }
+
+      const result = await $`lsof -i -P -n -p ${pid}`.nothrow().quiet().text();
+      const ports = new Set<number>();
+      for (const line of result.split('\n')) {
+        if (line.includes('LISTEN')) {
+          const portMatch = line.match(/:(\d+)\s+\(LISTEN\)/);
+          if (portMatch) {
+            ports.add(parseInt(portMatch[1]));
+          }
+        }
+      }
+      return Array.from(ports);
+    }
+  } catch {
+    return [];
+  }
+}
+

package/src/schema.ts

@@ -0,0 +1,2 @@
+// Schema is now defined inline in db.ts — re-export for backwards compatibility
+export { ProcessSchema, type Process } from "./db";

package/src/server.ts

@@ -0,0 +1,24 @@
+/**
+ * BGR Dashboard Server
+ * 
+ * Uses Melina.js to serve the dashboard app with file-based routing.
+ * All API endpoints and page rendering are handled by the dashboard/app/ directory.
+ * 
+ * Port selection is handled entirely by Melina:
+ *   - If BUN_PORT env var is set → uses that (explicit, will fail if busy)
+ *   - Otherwise → defaults to 3000, falls back to next available if busy
+ */
+import { start } from 'melina';
+import path from 'path';
+
+export async function startServer() {
+    const appDir = path.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: path.join(appDir, 'globals.css'),
+        port,
+    });
+}

package/src/table.ts

@@ -0,0 +1,230 @@
+#!/usr/bin/env bun
+
+// ./Documents/bgr/src/table.ts
+
+import chalk from "chalk";
+
+export interface TableColumn {
+  key: string;
+  header: string;
+  formatter?: (value: any) => string;
+  truncator?: (value: string, maxLength: number) => string;
+}
+
+export interface TableOptions {
+  maxWidth?: number;
+  padding?: number;
+  borderStyle?: "single" | "double" | "rounded" | "none";
+  showHeaders?: boolean;
+}
+
+export interface ProcessTableRow {
+  id: number;
+  pid: number;
+  name: string;
+  port: string;
+  command: string;
+  workdir: string;
+  status: string;
+  runtime: string;
+}
+
+// Get terminal width or use default
+export function getTerminalWidth(): number {
+  return process.stdout.columns || 120;
+}
+
+// Strip ANSI color codes for accurate length calculation
+function stripAnsi(str: string): string {
+  return str.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+// Default truncator: trims the end of a string
+function truncateString(str: string, maxLength: number): string {
+  const stripped = stripAnsi(str);
+  if (stripped.length <= maxLength) return str;
+  const ellipsis = "…";
+  // Ensure maxLength is at least 1 for the ellipsis
+  if (maxLength < 1) return "";
+  if (maxLength === 1) return ellipsis;
+
+  const targetLength = maxLength - ellipsis.length;
+  return str.substring(0, targetLength > 0 ? targetLength : 0) + ellipsis;
+}
+
+// Path truncator: trims the middle of a string
+function truncatePath(str: string, maxLength: number): string {
+  const stripped = stripAnsi(str);
+  if (stripped.length <= maxLength) return str;
+  const ellipsis = "…";
+  // Ensure maxLength is at least 3 for a start, middle, and end character
+  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);
+}
+
+// Calculate column widths by proportionally shrinking the widest columns
+export function calculateColumnWidths(
+  rows: any[],
+  columns: TableColumn[],
+  maxWidth: number,
+  padding: number = 2
+): Map<string, number> {
+  const separatorsWidth = columns.length + 1;
+  const paddingWidth = padding * columns.length;
+  const availableWidth = maxWidth - separatorsWidth - paddingWidth;
+
+  const naturalWidths = new Map<string, number>();
+
+  // 1. Calculate the natural width (max content length) for each column
+  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);
+
+  // 2. If it fits, we're done
+  if (totalNaturalWidth <= availableWidth) {
+    return naturalWidths;
+  }
+
+  // 3. If not, calculate the overage and shrink the widest columns iteratively
+  let overage = totalNaturalWidth - availableWidth;
+  const currentWidths = new Map(naturalWidths);
+
+  while (overage > 0) {
+    // Find the column that is currently the widest
+    let widestColKey: string | null = null;
+    let maxW = -1;
+    for (const [key, width] of currentWidths.entries()) {
+      if (width > maxW) {
+        maxW = width;
+        widestColKey = key;
+      }
+    }
+
+    // If no column can be shrunk (e.g., all are width 0), break
+    if (widestColKey === null || maxW <= 1) {
+      break;
+    }
+
+    // Shrink the widest column by 1
+    currentWidths.set(widestColKey, maxW - 1);
+    overage--;
+  }
+
+  return currentWidths;
+}
+
+function renderBorder(widths: number[], padding: number, style: string[]): string {
+  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;
+}
+
+export function renderHorizontalTable(
+  rows: any[],
+  columns: TableColumn[],
+  options: TableOptions = {}
+): { table: string; truncatedIndices: number[] } {
+  const { maxWidth = getTerminalWidth(), padding = 2, borderStyle = "rounded", showHeaders = true } = options;
+  if (rows.length === 0) return { table: chalk.gray("No data to display"), truncatedIndices: [] };
+
+  const borderChars = {
+    rounded: ["╭", "┬", "╮", "─", "│", "├", "┼", "┤", "╰", "┴", "╯"],
+    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<number>();
+  const lines: string[] = [];
+  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) => chalk.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("\n"), truncatedIndices: Array.from(truncatedIndices) };
+}
+
+export function renderVerticalTree(rows: any[], columns: TableColumn[]): string {
+  const lines: string[] = [];
+  rows.forEach((row, index) => {
+    if (index > 0) lines.push("");
+    const name = row.name ? `'${row.name}'` : `(ID: ${row.id})`;
+    lines.push(chalk.cyan(`▶ ${name}`));
+
+    columns.forEach((col) => {
+      const value = col.formatter ? col.formatter(row[col.key]) : String(row[col.key] || "");
+      lines.push(`  ├─ ${chalk.gray(`${col.header}:`)} ${value}`);
+    });
+  });
+  return lines.join("\n");
+}
+
+export function renderHybridTable(
+  rows: any[],
+  columns: TableColumn[],
+  options: TableOptions = {}
+): string {
+  const { table, truncatedIndices } = renderHorizontalTable(rows, columns, options);
+  const output = [table];
+
+  if (truncatedIndices.length > 0) {
+    const truncatedRows = truncatedIndices.map((i) => rows[i]);
+    output.push("\n" + renderVerticalTree(truncatedRows, columns));
+  }
+
+  return output.join("\n");
+}
+
+export function renderProcessTable(processes: ProcessTableRow[], options?: TableOptions): string {
+  const columns: TableColumn[] = [
+    { key: "id", header: "ID", formatter: (id) => chalk.blue(id) },
+    { key: "pid", header: "PID", formatter: (pid) => chalk.yellow(pid) },
+    { key: "name", header: "Name", formatter: (name) => chalk.cyan.bold(name) },
+    { key: "port", header: "Port", formatter: (port) => port === '-' ? chalk.gray(port) : chalk.hex('#FF6B6B')(port) },
+    { key: "command", header: "Command" },
+    { key: "workdir", header: "Directory", formatter: (dir) => chalk.gray(dir), truncator: truncatePath },
+    { key: "status", header: "Status" },
+    { key: "runtime", header: "Runtime", formatter: (runtime) => chalk.magenta(runtime) },
+  ];
+
+  return renderHybridTable(processes, columns, options);
+}