bgrun 3.12.12 → 3.12.13

package/README.md

@@ -409,8 +409,8 @@ If no `--config` is specified, bgrun looks for `.config.toml` in the working dir
 
 bgrun exposes its internals as importable TypeScript functions:
 
-> **Packaging note:** the CLI ships from `dist/index.js`, and the Bun programmatic API now resolves through the built `dist/api.js` artifact.
-> The runtime `src/` subset is still temporarily published for compatibility during the migration window, but package consumers should treat `dist/api.js` as the canonical API entry.
+> **Packaging note:** the CLI ships from `dist/index.js`, the Bun programmatic API resolves through `dist/api.js`, and the dashboard backend uses built `dist/*` runtime artifacts via `dashboard/lib/runtime.ts`.
+> Published packages are now `dist`-first; repository `src/` files remain the development/build source of truth and are not part of the runtime package surface.
 
 ```bash
 bun add bgrun

package/dashboard/lib/runtime.ts

@@ -0,0 +1,49 @@
+export {
+  db,
+  getAllProcesses,
+  getProcess,
+  insertProcess,
+  removeProcess,
+  removeProcessByName,
+  removeAllProcesses,
+  updateProcessPid,
+  updateProcessEnv,
+  getAllTemplates,
+  saveTemplate,
+  deleteTemplate,
+  getProcessHistory,
+  getRecentHistory,
+  addHistoryEntry,
+  getDependencyGraph,
+  addDependency,
+  removeDependency,
+  getStartOrder,
+  getDbInfo,
+  dbPath,
+  bgrHome,
+  isProcessRunning,
+  terminateProcess,
+  readFileTail,
+  getProcessPorts,
+  findChildPid,
+  findPidByPort,
+  getShellCommand,
+  killProcessOnPort,
+  waitForPortFree,
+  ensureDir,
+  getHomeDir,
+  isWindows,
+  getProcessBatchResources,
+  getProcessMemory,
+  reconcileProcessPids,
+  handleRun,
+  getVersion,
+  calculateRuntime,
+  parseEnvString,
+  validateDirectory,
+} from '../../dist/api.js'
+
+export { deployProcess, deployAllProcesses } from '../../dist/deploy.js'
+export { buildDepGraph } from '../../dist/deps.js'
+export { rotateAllLogs } from '../../dist/log-rotation.js'
+export { guardEvents, guardRestartCounts } from '../../dist/server.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bgrun",
-  "version": "3.12.12",
+  "version": "3.12.13",
   "description": "bgrun — A lightweight process manager for Bun",
   "type": "module",
   "main": "./dist/api.js",
@@ -17,23 +17,8 @@
   },
   "files": [
     "dist",
-    "src/api.ts",
-    "src/build.ts",
-    "src/config.ts",
-    "src/db.ts",
-    "src/deploy.ts",
-    "src/deps.ts",
-    "src/guard.ts",
-    "src/index.ts",
-    "src/log-rotation.ts",
-    "src/logger.ts",
-    "src/platform.ts",
-    "src/server.ts",
-    "src/table.ts",
-    "src/types.ts",
-    "src/utils.ts",
-    "src/commands",
     "dashboard/app",
+    "dashboard/lib",
     "scripts",
     "README.md",
     "image.png",

package/src/api.ts

@@ -1,116 +0,0 @@
-/**
- * BGR Public API (package: bgrun)
- * 
- * Import from 'bgrun' to use these functions in your own process-managing apps.
- * 
- * @example
- * ```ts
- * import { getAllProcesses, isProcessRunning, handleRun } from 'bgrun'
- * 
- * // List all managed processes
- * const processes = getAllProcesses()
- * 
- * // Check if a process is running
- * const alive = await isProcessRunning(process.pid)
- * 
- * // Start a new managed process
- * await handleRun({ name: 'my-app', command: 'bun run dev', directory: './my-app', action: 'run', remoteName: '' })
- * ```
- */
-
-// --- Types ---
-export type { Process } from './db'
-export type { CommandOptions } from './types'
-
-// --- Database Operations ---
-export {
-    db,
-    getAllProcesses,
-    getProcess,
-    insertProcess,
-    removeProcess,
-    removeProcessByName,
-    removeAllProcesses,
-    updateProcessPid,
-    updateProcessEnv,
-    getAllTemplates,
-    saveTemplate,
-    deleteTemplate,
-    getProcessHistory,
-    getRecentHistory,
-    addHistoryEntry,
-    getDependencyGraph,
-    addDependency,
-    removeDependency,
-    getStartOrder,
-    retryDatabaseOperation,
-    getDbInfo,
-    dbPath,
-    bgrHome,
-} from './db'
-
-// --- Process Operations ---
-export {
-    isProcessRunning,
-    terminateProcess,
-    readFileTail,
-    getProcessPorts,
-    findChildPid,
-    findPidByPort,
-    getShellCommand,
-    killProcessOnPort,
-    waitForPortFree,
-    ensureDir,
-    getHomeDir,
-    isWindows,
-    getProcessBatchResources,
-    getProcessMemory,
-    reconcileProcessPids,
-} from './platform'
-
-// --- High-Level Commands ---
-export { handleRun } from './commands/run'
-
-// --- Utilities ---
-export { getVersion, calculateRuntime, parseEnvString, validateDirectory } from './utils'
-
-// --- Default Export (namespace style) ---
-import {
-    db,
-    getAllProcesses,
-    getProcess,
-    insertProcess,
-    removeProcess,
-    removeProcessByName,
-    removeAllProcesses,
-    updateProcessPid,
-    updateProcessEnv,
-    getAllTemplates,
-    saveTemplate,
-    deleteTemplate,
-    getProcessHistory,
-    getRecentHistory,
-    addHistoryEntry,
-    getDependencyGraph,
-    addDependency,
-    removeDependency,
-    getStartOrder,
-    retryDatabaseOperation,
-    getDbInfo,
-    dbPath,
-    bgrHome,
-} from './db'
-import { isProcessRunning, terminateProcess, readFileTail, getProcessPorts, findChildPid, findPidByPort, getShellCommand, killProcessOnPort, waitForPortFree, ensureDir, getHomeDir, isWindows, getProcessBatchResources, getProcessMemory, reconcileProcessPids } from './platform'
-import { handleRun } from './commands/run'
-import { getVersion, calculateRuntime, parseEnvString, validateDirectory } from './utils'
-
-export default {
-    db, getAllProcesses, getProcess, insertProcess, removeProcess, removeProcessByName, removeAllProcesses,
-    updateProcessPid, updateProcessEnv, getAllTemplates, saveTemplate, deleteTemplate,
-    getProcessHistory, getRecentHistory, addHistoryEntry,
-    getDependencyGraph, addDependency, removeDependency, getStartOrder,
-    retryDatabaseOperation, getDbInfo, dbPath, bgrHome,
-    isProcessRunning, terminateProcess, readFileTail, getProcessPorts, findChildPid, findPidByPort, getShellCommand, killProcessOnPort, waitForPortFree, ensureDir, getHomeDir, isWindows, getProcessBatchResources, getProcessMemory, reconcileProcessPids,
-    handleRun,
-    getVersion, calculateRuntime, parseEnvString, validateDirectory,
-}

package/src/build.ts

@@ -1,31 +0,0 @@
-console.log("Starting build process for bgrun...");
-
-const entrypoints = [
-  './src/index.ts',
-  './src/api.ts',
-  './src/server.ts',
-  './src/deploy.ts',
-  './src/deps.ts',
-  './src/log-rotation.ts',
-];
-const result = await Bun.build({
-  entrypoints,
-  outdir: './dist',
-  target: 'bun',
-  format: 'esm',
-  minify: false,
-  // Mark all packages as external to rely on node_modules
-  // This avoids bundling native modules or mismatched React versions
-  packages: "external",
-});
-
-if (!result.success) {
-  console.error("Build failed");
-  for (const message of result.logs) {
-    console.error(message);
-  }
-  process.exit(1);
-}
-
-const builtFiles = result.outputs.map((output) => output.path.split(/[\\/]/).pop()).filter(Boolean);
-console.log(`Build successful! Artifacts: ${builtFiles.join(', ')}`);

package/src/commands/cleanup.ts

@@ -1,141 +0,0 @@
-
-import { getProcess, removeProcessByName, removeProcess, getAllProcesses, removeAllProcesses, updateProcessPid } from "../db";
-import { isProcessRunning, terminateProcess, getProcessPorts, killProcessOnPort, waitForPortFree } from "../platform";
-import { announce, error } from "../logger";
-import * as fs from "fs";
-
-export async function handleDelete(name: string) {
-    const process = getProcess(name);
-
-    if (!process) {
-        error(`No process found named '${name}'`);
-        return;
-    }
-
-    const isRunning = await isProcessRunning(process.pid);
-    if (isRunning) {
-        await terminateProcess(process.pid);
-    }
-
-    if (fs.existsSync(process.stdout_path)) {
-        try { fs.unlinkSync(process.stdout_path); } catch { }
-    }
-    if (fs.existsSync(process.stderr_path)) {
-        try { fs.unlinkSync(process.stderr_path); } catch { }
-    }
-
-    removeProcessByName(name);
-    announce(`Process '${name}' has been ${isRunning ? 'stopped and ' : ''}deleted`, "Process Deleted");
-}
-
-export 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 (fs.existsSync(proc.stdout_path)) {
-                try { fs.unlinkSync(proc.stdout_path); deletedLogs++; } catch { }
-            }
-            if (fs.existsSync(proc.stderr_path)) {
-                try { fs.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"
-        );
-    }
-}
-
-export async function handleStop(name: string) {
-    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;
-    }
-
-    // Detect ports the process is using BEFORE killing it
-    const ports = await getProcessPorts(proc.pid);
-
-    await terminateProcess(proc.pid);
-
-    // Also kill by detected ports as safety net
-    for (const port of ports) {
-        await killProcessOnPort(port);
-    }
-
-    // Mark PID as 0 — prevents reconcileProcessPids from re-attaching
-    // a random matching process as this one
-    updateProcessPid(name, 0);
-
-    announce(`Process '${name}' has been stopped (kept in registry).`, "Process Stopped");
-}
-
-export async function handleDeleteAll() {
-    const processes = getAllProcesses();
-    if (processes.length === 0) {
-        announce("There are no processes to delete.", "Delete All");
-        return;
-    }
-
-    let killedCount = 0;
-    let portsFreed = 0;
-
-    for (const proc of processes) {
-        const running = await isProcessRunning(proc.pid);
-
-        if (running) {
-            // Detect ports BEFORE killing so we can clean them up
-            const ports = await getProcessPorts(proc.pid);
-
-            // Force-kill the process tree
-            await terminateProcess(proc.pid, true);
-            killedCount++;
-
-            // Kill anything still holding the ports
-            for (const port of ports) {
-                await killProcessOnPort(port);
-                const freed = await waitForPortFree(port, 3000);
-                if (!freed) {
-                    await killProcessOnPort(port);
-                    await waitForPortFree(port, 2000);
-                }
-                portsFreed++;
-            }
-        }
-
-        // Clean up log files
-        if (fs.existsSync(proc.stdout_path)) {
-            try { fs.unlinkSync(proc.stdout_path); } catch { }
-        }
-        if (fs.existsSync(proc.stderr_path)) {
-            try { fs.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");
-}

package/src/commands/details.ts

@@ -1,60 +0,0 @@
-
-import { error, announce } from "../logger";
-import { getProcess, updateProcessPid } from "../db";
-import { isProcessRunning, calculateRuntime, parseEnvString } from "../utils";
-import { getProcessPorts, reconcileProcessPids } from "../platform";
-import chalk from "chalk";
-
-export async function showDetails(name: string) {
-    const proc = getProcess(name);
-    if (!proc) {
-        error(`No process found named '${name}'`);
-        return;
-    }
-
-    let isRunning = await isProcessRunning(proc.pid, proc.command);
-
-    // Reconcile stale PID: cmd.exe wrapper may have exited while bun.exe child lives
-    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]),
-        );
-        const newPid = reconciled.get(proc.name);
-        if (newPid) {
-            updateProcessPid(proc.name, newPid);
-            (proc as any).pid = newPid;
-            isRunning = true;
-        }
-    }
-    const runtime = calculateRuntime(proc.timestamp);
-    const envVars = parseEnvString(proc.env);
-
-    // Detect actual ports via OS
-    const ports = isRunning ? await getProcessPorts(proc.pid) : [];
-
-    const portDisplay = ports.length > 0
-        ? ports.map(p => chalk.hex('#FF6B6B')(`:${p}`)).join(', ')
-        : null;
-
-    const details = `
-${chalk.bold('Process Details:')}
-${chalk.gray('═'.repeat(50))}
-${chalk.cyan.bold('Name:')} ${proc.name}
-${chalk.yellow.bold('PID:')} ${proc.pid}${portDisplay ? `\n${chalk.hex('#FF6B6B').bold('Port:')} ${portDisplay}` : ''}
-${chalk.bold('Status:')} ${isRunning ? chalk.green.bold("● Running") : chalk.red.bold("○ Stopped")}
-${chalk.magenta.bold('Runtime:')} ${runtime}
-${chalk.blue.bold('Working Directory:')} ${proc.workdir}
-${chalk.white.bold('Command:')} ${proc.command}
-${chalk.gray.bold('Config Path:')} ${proc.configPath}
-${chalk.green.bold('Stdout Path:')} ${proc.stdout_path}
-${chalk.red.bold('Stderr Path:')} ${proc.stderr_path}
-
-${chalk.bold('🔧 Environment Variables:')}
-${chalk.gray('═'.repeat(50))}
-${Object.entries(envVars)
-            .map(([key, value]) => `${chalk.cyan.bold(key)} = ${chalk.yellow(value)}`)
-            .join('\n')}
-`;
-    announce(details, `Process Details: ${name}`);
-}

package/src/commands/list.ts

@@ -1,133 +0,0 @@
-import chalk from "chalk";
-import { renderProcessTable } from "../table";
-import type { ProcessTableRow } from "../table";
-import { getAllProcesses, updateProcessPid } from "../db";
-import { announce } from "../logger";
-import { isProcessRunning, calculateRuntime, parseEnvString } from "../utils";
-import { getProcessPorts, getProcessBatchResources, reconcileProcessPids } from "../platform";
-import { measure } from "measure-fn";
-
-function formatMemory(bytes: number): string {
-    if (bytes === 0) return '-';
-    const mb = bytes / (1024 * 1024);
-    if (mb >= 1024) return `${(mb / 1024).toFixed(1)} GB`;
-    return `${Math.round(mb)} MB`;
-}
-
-export async function showAll(opts?: { json?: boolean; filter?: string }) {
-    const processes = getAllProcesses();
-
-    // Apply filter by env.BGR_GROUP if provided
-    const filtered = processes.filter((proc) => {
-        if (!opts?.filter) return true;
-        const envVars = parseEnvString(proc.env);
-        return envVars["BGR_GROUP"] === opts.filter;
-    });
-
-    // ─── PID Reconciliation ──────────────────────────────────────────
-    // On Windows, the stored PID may be a dead cmd.exe wrapper while the
-    // actual bun.exe child is still running.  Detect dead PIDs up-front,
-    // reconcile them in one batch PowerShell call, and patch the DB so
-    // subsequent invocations are stable (no flicker).
-    const deadPids = new Set<number>();
-    const aliveCache = new Map<number, boolean>();
-
-    for (const proc of filtered) {
-        const alive = await isProcessRunning(proc.pid, proc.command);
-        aliveCache.set(proc.pid, alive);
-        if (!alive && proc.pid > 0) deadPids.add(proc.pid);
-    }
-
-    if (deadPids.size > 0) {
-        const reconciled = await reconcileProcessPids(
-            filtered.map(p => ({ name: p.name, pid: p.pid, command: p.command, workdir: p.workdir })),
-            deadPids,
-        );
-
-        for (const [name, newPid] of reconciled) {
-            updateProcessPid(name, newPid);
-            // Patch the in-memory record so the rest of this function sees
-            // the corrected PID without re-querying the DB.
-            const proc = filtered.find(p => p.name === name);
-            if (proc) {
-                (proc as any).pid = newPid;
-                aliveCache.set(newPid, true);
-            }
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────
-
-    if (opts?.json) {
-        // JSON output with filtered env variables
-        const jsonData: any[] = [];
-
-        for (const proc of filtered) {
-            const isRunning = aliveCache.get(proc.pid) ?? 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;
-    }
-
-    // Table output
-    const tableData: ProcessTableRow[] = [];
-
-    // Batch fetch memory for all PIDs
-    const allPids = filtered.map(p => p.pid);
-    const resourceMap = await getProcessBatchResources(allPids);
-
-    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) : [];
-        tableData.push({
-            id: proc.id,
-            pid: proc.pid,
-            name: proc.name,
-            port: ports.length > 0 ? ports.map(p => `:${p}`).join(',') : '-',
-            memory: formatMemory(mem),
-            command: proc.command,
-            workdir: proc.workdir,
-            status: isRunning
-                ? chalk.green.bold("● Running")
-                : chalk.red.bold("○ Stopped"),
-            runtime: 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(
-        chalk.cyan(
-            `Total: ${tableData.length} processes (${chalk.green(`${runningCount} running`)}, ${chalk.red(`${stoppedCount} stopped`)})`
-        )
-    );
-}

package/src/commands/logs.ts

@@ -1,49 +0,0 @@
-import { getProcess } from "../db";
-import { error } from "../logger";
-import { readFileTail } from "../platform";
-import chalk from "chalk";
-import * as fs from "fs";
-
-export async function showLogs(name: string, logType: 'stdout' | 'stderr' | 'both' = 'both', lines?: number) {
-    const proc = getProcess(name);
-    if (!proc) {
-        error(`No process found named '${name}'`);
-        return; // TS shut up
-    }
-
-    if (logType === 'both' || logType === 'stdout') {
-        console.log(chalk.green.bold(`📄 Stdout logs for ${name}:`));
-        console.log(chalk.gray('═'.repeat(50)));
-
-        if (fs.existsSync(proc.stdout_path)) {
-            try {
-                const output = await readFileTail(proc.stdout_path, lines);
-                console.log(output || chalk.gray('(no output)'));
-            } catch (err) {
-                console.log(chalk.red(`Error reading stdout: ${err}`));
-            }
-        } else {
-            console.log(chalk.gray('(log file not found)'));
-        }
-
-        if (logType === 'both') {
-            console.log('\n');
-        }
-    }
-
-    if (logType === 'both' || logType === 'stderr') {
-        console.log(chalk.red.bold(`📄 Stderr logs for ${name}:`));
-        console.log(chalk.gray('═'.repeat(50)));
-
-        if (fs.existsSync(proc.stderr_path)) {
-            try {
-                const output = await readFileTail(proc.stderr_path, lines);
-                console.log(output || chalk.gray('(no errors)'));
-            } catch (err) {
-                console.log(chalk.red(`Error reading stderr: ${err}`));
-            }
-        } else {
-            console.log(chalk.gray('(log file not found)'));
-        }
-    }
-}