bgrun 3.3.1 → 3.3.3

package/README.md

@@ -1,32 +1,32 @@
-<![CDATA[<div align="center">
+<div align="center">
 
-# 🦎 BGR
+# ⚡ bgrun
 
-**Background Runner — a modern process manager built on Bun**
+**Bun Background Runner — a modern process manager built on Bun**
 
-[![npm](https://img.shields.io/npm/v/bgr?color=F7A41D&label=npm&logo=npm)](https://www.npmjs.com/package/bgr)
+[![npm](https://img.shields.io/npm/v/bgrun?color=F7A41D&label=npm&logo=npm)](https://www.npmjs.com/package/bgrun)
 [![bun](https://img.shields.io/badge/runtime-bun-F7A41D?logo=bun)](https://bun.sh/)
-[![license](https://img.shields.io/npm/l/bgr)](./LICENSE)
+[![license](https://img.shields.io/npm/l/bgrun)](./LICENSE)
 
 Start, stop, restart, and monitor any process — from dev servers to Docker containers.
 Zero config. One command. Beautiful dashboard included.
 
 ```
-bun install -g bgr
+bun install -g bgrun
 ```
 
 </div>
 
 ---
 
-## Why BGR?
+## Why bgrun?
 
-| Feature | PM2 | bgr |
-|---------|-----|-----|
+| Feature | PM2 | bgrun |
+|---------|-----|-------|
 | Runtime | Node.js | Bun (5× faster startup) |
-| Install | `npm i -g pm2` (50+ deps) | `bun i -g bgr` (minimal deps) |
+| Install | `npm i -g pm2` (50+ deps) | `bun i -g bgrun` (minimal deps) |
 | Config format | JSON / JS / YAML | TOML (or none at all) |
-| Dashboard | `pm2 monit` (TUI) | `bgr --dashboard` (full web UI) |
+| Dashboard | `pm2 monit` (TUI) | `bgrun --dashboard` (full web UI) |
 | Language support | Any | Any |
 | Docker-aware | ❌ | ✅ detects container status |
 | Port management | Manual | Auto-detect & cleanup |
@@ -34,25 +34,27 @@ bun install -g bgr
 | Programmatic API | ✅ | ✅ (first-class TypeScript) |
 | Process persistence | ✅ | ✅ (SQLite) |
 
+> **Note:** The CLI is available as both `bgrun` and `bgr` (alias). All examples below use `bgrun`.
+
 ---
 
 ## Quick Start
 
 ```bash
 # Install globally
-bun install -g bgr
+bun install -g bgrun
 
 # Start a process
-bgr --name my-api --directory ./my-project --command "bun run server.ts"
+bgrun --name my-api --directory ./my-project --command "bun run server.ts"
 
 # List all processes
-bgr
+bgrun
 
 # Open the web dashboard
-bgr --dashboard
+bgrun --dashboard
 ```
 
-That's it. BGR tracks the PID, captures stdout/stderr, detects the port, and survives terminal close.
+That's it. bgrun tracks the PID, captures stdout/stderr, detects the port, and survives terminal close.
 
 ---
 
@@ -77,7 +79,7 @@ That's it. BGR tracks the PID, captures stdout/stderr, detects the port, and sur
 ### Starting a process
 
 ```bash
-bgr --name my-api \
+bgrun --name my-api \
     --directory ~/projects/my-api \
     --command "bun run server.ts"
 ```
@@ -85,34 +87,34 @@ bgr --name my-api \
 Short form — if you're already *in* the project directory:
 
 ```bash
-bgr --name my-api --command "bun run server.ts"
-# bgr uses current directory by default
+bgrun --name my-api --command "bun run server.ts"
+# bgrun uses current directory by default
 ```
 
 ### Listing processes
 
 ```bash
-bgr                  # Pretty table
-bgr --json           # Machine-readable JSON
-bgr --filter api     # Filter by group (BGR_GROUP env)
+bgrun                  # Pretty table
+bgrun --json           # Machine-readable JSON
+bgrun --filter api     # Filter by group (BGR_GROUP env)
 ```
 
 ### Viewing a process
 
 ```bash
-bgr my-api           # Show status, PID, port, runtime, command
-bgr my-api --logs    # Show stdout + stderr interleaved
-bgr my-api --logs --log-stdout --lines 50  # Last 50 stdout lines only
+bgrun my-api           # Show status, PID, port, runtime, command
+bgrun my-api --logs    # Show stdout + stderr interleaved
+bgrun my-api --logs --log-stdout --lines 50  # Last 50 stdout lines only
 ```
 
 ### Stopping, restarting, deleting
 
 ```bash
-bgr --stop my-api       # Graceful stop (SIGTERM → SIGKILL)
-bgr --restart my-api     # Stop then start again with same command
-bgr --delete my-api      # Stop and remove from database
-bgr --clean              # Remove all stopped processes
-bgr --nuke               # ☠️  Delete everything
+bgrun --stop my-api       # Graceful stop (SIGTERM → SIGKILL)
+bgrun --restart my-api     # Stop then start again with same command
+bgrun --delete my-api      # Stop and remove from database
+bgrun --clean              # Remove all stopped processes
+bgrun --nuke               # ☠️  Delete everything
 ```
 
 ### Force restart
@@ -120,7 +122,7 @@ bgr --nuke               # ☠️  Delete everything
 When a process is stuck or its port is orphaned:
 
 ```bash
-bgr --name my-api --command "bun run server.ts" --force
+bgrun --name my-api --command "bun run server.ts" --force
 ```
 
 `--force` will:
@@ -134,10 +136,10 @@ bgr --name my-api --command "bun run server.ts" --force
 
 ## Dashboard
 
-BGR ships with a built-in web dashboard for managing all your processes visually.
+bgrun ships with a built-in web dashboard for managing all your processes visually.
 
 ```bash
-bgr --dashboard
+bgrun --dashboard
 ```
 
 The dashboard provides:
@@ -145,7 +147,7 @@ The dashboard provides:
 - **Start/stop/restart/delete** actions with one click
 - **Log viewer** with monospace display and auto-scroll
 - **Process detail drawer** with stdout/stderr tabs
-- **Auto-refresh** every 3 seconds
+- **Auto-refresh** every 5 seconds
 
 ### Dashboard port selection
 
@@ -153,21 +155,21 @@ The dashboard uses [Melina.js](https://github.com/7flash/melina.js) for serving
 
 | Scenario | Behavior |
 |----------|----------|
-| `bgr --dashboard` | Starts on port 3000. If busy, auto-falls back to 3001, 3002, etc. |
-| `BUN_PORT=4000 bgr --dashboard` | Starts on port 4000. Fails with error if port is busy. |
-| `bgr --dashboard --port 5000` | Same as `BUN_PORT=5000` — explicit, no fallback. |
+| `bgrun --dashboard` | Starts on port 3000. If busy, auto-falls back to 3001, 3002, etc. |
+| `BUN_PORT=4000 bgrun --dashboard` | Starts on port 4000. Fails with error if port is busy. |
+| `bgrun --dashboard --port 5000` | Same as `BUN_PORT=5000` — explicit, no fallback. |
 | Dashboard already running | Prints current URL and PID instead of starting a second instance. |
 
-The actual port is always detected from the running process and displayed correctly in `bgr` output.
+The actual port is always detected from the running process and displayed correctly in `bgrun` output.
 
 ---
 
 ## File Watching
 
-For development, BGR can watch for file changes and auto-restart:
+For development, bgrun can watch for file changes and auto-restart:
 
 ```bash
-bgr --name frontend \
+bgrun --name frontend \
     --directory ~/projects/frontend \
     --command "bun run dev" \
     --watch
@@ -176,7 +178,7 @@ bgr --name frontend \
 This monitors the working directory for changes and restarts the process when files are modified. Combine with `--force` to ensure clean restarts:
 
 ```bash
-bgr --name api \
+bgrun --name api \
     --command "bun run server.ts" \
     --watch \
     --force \
@@ -187,20 +189,20 @@ bgr --name api \
 
 ## Port Handling
 
-BGR automatically detects which TCP ports a process is listening on by querying the OS. This means:
+bgrun automatically detects which TCP ports a process is listening on by querying the OS. This means:
 
-- **No port configuration needed** — BGR discovers ports from `netstat`
-- **No environment variable assumptions** — BGR doesn't guess `PORT` or `BUN_PORT`
+- **No port configuration needed** — bgrun discovers ports from `netstat`
+- **No environment variable assumptions** — bgrun doesn't guess `PORT` or `BUN_PORT`
 - **Clean restarts** — `--force` kills all orphaned port bindings before restarting
-- **Accurate display** — the port shown in `bgr` output is the *actual* bound port
+- **Accurate display** — the port shown in `bgrun` output is the *actual* bound port
 
 ### How it works
 
 ```
-1. bgr spawns your process
+1. bgrun spawns your process
 2. Process starts and binds to a port (however it wants)
-3. bgr queries `netstat -ano` (Windows) or `ss -tlnp` (Linux)
-4. bgr finds all TCP LISTEN ports for the process PID
+3. bgrun queries `netstat -ano` (Windows) or `ss -tlnp` (Linux)
+4. bgrun finds all TCP LISTEN ports for the process PID
 5. These ports are displayed in the table and used for cleanup
 ```
 
@@ -209,7 +211,7 @@ BGR automatically detects which TCP ports a process is listening on by querying
 If you `--force` restart a process and its old port is still held by a zombie:
 
 ```
-1. bgr detects ports held by the old PID
+1. bgrun detects ports held by the old PID
 2. Sends SIGTERM to the old process
 3. Kills any remaining processes on those ports
 4. Waits for ports to become free (up to 5 seconds)
@@ -220,36 +222,36 @@ If you `--force` restart a process and its old port is still held by a zombie:
 
 ## Docker Integration
 
-BGR can manage Docker containers alongside regular processes:
+bgrun can manage Docker containers alongside regular processes:
 
 ```bash
 # Start a Postgres container
-bgr --name postgres \
+bgrun --name postgres \
     --command "docker run --name bgr-postgres -p 5432:5432 -e POSTGRES_PASSWORD=secret postgres:16"
 
 # Start a Redis container
-bgr --name redis \
+bgrun --name redis \
     --command "docker run --name bgr-redis -p 6379:6379 redis:7-alpine"
 ```
 
-### How BGR handles Docker
+### How bgrun handles Docker
 
-BGR is **Docker-aware** — when it detects a `docker run` command, it:
+bgrun is **Docker-aware** — when it detects a `docker run` command, it:
 
 1. **Checks container status** via `docker inspect` instead of checking the PID
-2. **Handles container lifecycle** — stops containers with `docker stop` on `bgr --stop`
+2. **Handles container lifecycle** — stops containers with `docker stop` on `bgrun --stop`
 3. **Reports correct status** — shows Running/Stopped based on container state, not process state
 
 ### Docker Compose alternative
 
-Instead of `docker-compose.yml`, use BGR to orchestrate containers alongside your app:
+Instead of `docker-compose.yml`, use bgrun to orchestrate containers alongside your app:
 
 ```bash
 #!/bin/bash
 # start-stack.sh
 
 # Database
-bgr --name db \
+bgrun --name db \
     --command "docker run --name bgr-db -p 5432:5432 \
               -v pgdata:/var/lib/postgresql/data \
               -e POSTGRES_DB=myapp \
@@ -258,19 +260,19 @@ bgr --name db \
     --force
 
 # Cache
-bgr --name cache \
+bgrun --name cache \
     --command "docker run --name bgr-cache -p 6379:6379 redis:7-alpine" \
     --force
 
 # Your app (not Docker, just a regular process)
-bgr --name api \
+bgrun --name api \
     --directory ~/projects/my-api \
     --command "bun run server.ts" \
     --config production.toml \
     --force
 
 # See everything
-bgr
+bgrun
 ```
 
 The advantage over Docker Compose: your app processes and Docker containers are managed in the **same place** with the **same commands**.
@@ -279,16 +281,16 @@ The advantage over Docker Compose: your app processes and Docker containers are
 
 ## Caddy Reverse Proxy
 
-BGR pairs naturally with [Caddy](https://caddyserver.com/) for production deployments with automatic HTTPS.
+bgrun pairs naturally with [Caddy](https://caddyserver.com/) for production deployments with automatic HTTPS.
 
 ### Basic setup
 
 ```bash
-# Start your app on any port (BGR detects it)
-bgr --name my-api --command "bun run server.ts" --force
+# Start your app on any port (bgrun detects it)
+bgrun --name my-api --command "bun run server.ts" --force
 
 # Check which port it got
-bgr
+bgrun
 # → my-api  ● Running  :3000  bun run server.ts
 ```
 
@@ -308,55 +310,35 @@ dashboard.example.com {
 
 ```bash
 # Start services
-bgr --name api       --command "bun run api/server.ts"     --force
-bgr --name frontend  --command "bun run frontend/server.ts" --force
-bgr --name admin     --command "bun run admin/server.ts"    --force
+bgrun --name api       --command "bun run api/server.ts"     --force
+bgrun --name frontend  --command "bun run frontend/server.ts" --force
+bgrun --name admin     --command "bun run admin/server.ts"    --force
 
 # Start dashboard
-bgr --dashboard
+bgrun --dashboard
 ```
 
-**Caddyfile:**
-
-```caddy
-api.example.com {
-    reverse_proxy localhost:3000
-}
+### Managing Caddy with bgrun
 
-app.example.com {
-    reverse_proxy localhost:3001
-}
-
-admin.example.com {
-    reverse_proxy localhost:3002
-}
-
-status.example.com {
-    reverse_proxy localhost:3003  # BGR dashboard
-}
-```
-
-### Managing Caddy with BGR
-
-You can even manage Caddy itself as a BGR process:
+You can even manage Caddy itself as a bgrun process:
 
 ```bash
-bgr --name caddy \
+bgrun --name caddy \
     --directory /etc/caddy \
     --command "caddy run --config Caddyfile" \
     --force
 ```
 
-Now `bgr` shows your entire stack — app servers, databases, and reverse proxy — in one place.
+Now `bgrun` shows your entire stack — app servers, databases, and reverse proxy — in one place.
 
 ---
 
 ## TOML Configuration
 
-BGR loads TOML config files and flattens them into environment variables:
+bgrun loads TOML config files and flattens them into environment variables:
 
 ```bash
-bgr --name api --command "bun run server.ts" --config production.toml
+bgrun --name api --command "bun run server.ts" --config production.toml
 ```
 
 ```toml
@@ -386,16 +368,16 @@ AUTH_SESSION_TTL=3600
 
 The convention: `[section]` becomes the prefix, `key` becomes the suffix, joined with `_`, uppercased.
 
-If no `--config` is specified, BGR looks for `.config.toml` in the working directory automatically.
+If no `--config` is specified, bgrun looks for `.config.toml` in the working directory automatically.
 
 ---
 
 ## Programmatic API
 
-BGR exposes its internals as importable TypeScript functions:
+bgrun exposes its internals as importable TypeScript functions:
 
 ```bash
-bun add bgr
+bun add bgrun
 ```
 
 ### Process management
@@ -410,7 +392,7 @@ import {
   getProcessPorts,
   readFileTail,
   calculateRuntime,
-} from 'bgr'
+} from 'bgrun'
 
 // List all processes
 const procs = getAllProcesses()
@@ -435,10 +417,10 @@ if (proc) {
 }
 
 // Read logs
-const proc = getProcess('my-api')
-if (proc) {
-  const stdout = await readFileTail(proc.stdout_path, 100) // last 100 lines
-  const stderr = await readFileTail(proc.stderr_path, 100)
+const myProc = getProcess('my-api')
+if (myProc) {
+  const stdout = await readFileTail(myProc.stdout_path, 100) // last 100 lines
+  const stderr = await readFileTail(myProc.stderr_path, 100)
 }
 
 // Stop a process
@@ -448,7 +430,7 @@ await terminateProcess(proc.pid)
 ### Build a custom dashboard
 
 ```typescript
-import { getAllProcesses, isProcessRunning, calculateRuntime } from 'bgr'
+import { getAllProcesses, isProcessRunning, calculateRuntime } from 'bgrun'
 
 // Express/Hono/Elysia endpoint
 export async function GET() {
@@ -473,20 +455,20 @@ If you're coming from PM2, here's a direct mapping of commands:
 
 ### Command mapping
 
-| PM2 | BGR |
-|-----|-----|
-| `pm2 start app.js --name api` | `bgr --name api --command "node app.js"` |
+| PM2 | bgrun |
+|-----|-------|
+| `pm2 start app.js --name api` | `bgrun --name api --command "node app.js"` |
 | `pm2 start app.js -i max` | *(cluster mode not supported — use multiple named processes)* |
-| `pm2 list` | `bgr` |
-| `pm2 show api` | `bgr api` |
-| `pm2 logs api` | `bgr api --logs` |
-| `pm2 logs api --lines 50` | `bgr api --logs --lines 50` |
-| `pm2 stop api` | `bgr --stop api` |
-| `pm2 restart api` | `bgr --restart api` |
-| `pm2 delete api` | `bgr --delete api` |
-| `pm2 flush` | `bgr --clean` |
-| `pm2 kill` | `bgr --nuke` |
-| `pm2 monit` | `bgr --dashboard` |
+| `pm2 list` | `bgrun` |
+| `pm2 show api` | `bgrun api` |
+| `pm2 logs api` | `bgrun api --logs` |
+| `pm2 logs api --lines 50` | `bgrun api --logs --lines 50` |
+| `pm2 stop api` | `bgrun --stop api` |
+| `pm2 restart api` | `bgrun --restart api` |
+| `pm2 delete api` | `bgrun --delete api` |
+| `pm2 flush` | `bgrun --clean` |
+| `pm2 kill` | `bgrun --nuke` |
+| `pm2 monit` | `bgrun --dashboard` |
 | `pm2 save` / `pm2 resurrect` | *(automatic — processes persist in SQLite)* |
 
 ### ecosystem.config.js → TOML + shell script
@@ -513,7 +495,7 @@ module.exports = {
 }
 ```
 
-**BGR equivalent:**
+**bgrun equivalent:**
 
 ```toml
 # api.toml
@@ -527,32 +509,32 @@ env = "production"
 ```bash
 #!/bin/bash
 # start.sh
-bgr --name api    --directory ./api     --command "node server.js" --config api.toml --force
-bgr --name worker --directory ./workers --command "node worker.js" --force
+bgrun --name api    --directory ./api     --command "node server.js" --config api.toml --force
+bgrun --name worker --directory ./workers --command "node worker.js" --force
 ```
 
 ### Key differences
 
-1. **No cluster mode** — BGR manages independent processes. For multi-core, run multiple named instances (`api-1`, `api-2`) behind a load balancer.
+1. **No cluster mode** — bgrun manages independent processes. For multi-core, run multiple named instances (`api-1`, `api-2`) behind a load balancer.
 
-2. **No `pm2 startup`** — BGR doesn't install itself as a system service. Use your OS init system (systemd, launchd, Windows Task Scheduler) to run BGR at boot:
+2. **No `pm2 startup`** — bgrun doesn't install itself as a system service. Use your OS init system (systemd, launchd, Windows Task Scheduler) to run bgrun at boot:
 
    ```ini
-   # /etc/systemd/system/bgr-api.service
+   # /etc/systemd/system/bgrun-api.service
    [Unit]
-   Description=My API via BGR
+   Description=My API via bgrun
 
    [Service]
-   ExecStart=/usr/local/bin/bgr --name api --directory /var/www/api --command "bun run server.ts" --force
+   ExecStart=/usr/local/bin/bgrun --name api --directory /var/www/api --command "bun run server.ts" --force
    Restart=always
 
    [Install]
    WantedBy=multi-user.target
    ```
 
-3. **No log rotation** — BGR writes to plain text files in `~/.bgr/`. Use `logrotate` or similar tools, or specify custom log paths with `--stdout` and `--stderr`.
+3. **No log rotation** — bgrun writes to plain text files in `~/.bgr/`. Use `logrotate` or similar tools, or specify custom log paths with `--stdout` and `--stderr`.
 
-4. **Bun required** — BGR runs on Bun, but the *processes it manages* can be anything: Node.js, Python, Ruby, Go, Docker, shell scripts.
+4. **Bun required** — bgrun runs on Bun, but the *processes it manages* can be anything: Node.js, Python, Ruby, Go, Docker, shell scripts.
 
 ---
 
@@ -560,10 +542,10 @@ bgr --name worker --directory ./workers --command "node worker.js" --force
 
 ### What happens when a process crashes?
 
-BGR records the process as **Stopped**. The PID and log files are preserved so you can inspect what happened:
+bgrun records the process as **Stopped**. The PID and log files are preserved so you can inspect what happened:
 
 ```bash
-bgr my-api --logs --log-stderr
+bgrun my-api --logs --log-stderr
 ```
 
 For auto-restart on crash, use the guard script:
@@ -572,25 +554,25 @@ For auto-restart on crash, use the guard script:
 bun run guard.ts my-api 30  # Check every 30 seconds, restart if dead
 ```
 
-### What happens on `bgr --force` if the port is stuck?
+### What happens on `bgrun --force` if the port is stuck?
 
-BGR queries the OS for all TCP ports held by the old PID, kills them, and waits up to 5 seconds for cleanup. If ports are still held after that, the new process starts anyway (and will likely pick a different port).
+bgrun queries the OS for all TCP ports held by the old PID, kills them, and waits up to 5 seconds for cleanup. If ports are still held after that, the new process starts anyway (and will likely pick a different port).
 
 ### What happens if I start two processes with the same name?
 
-The new process replaces the old one. If the old one is still running, use `--force` to kill it first. Without `--force`, BGR will refuse to start if a process with that name is already running.
+The new process replaces the old one. If the old one is still running, use `--force` to kill it first. Without `--force`, bgrun will refuse to start if a process with that name is already running.
 
-### What happens if BGR itself is killed?
+### What happens if bgrun itself is killed?
 
-The managed processes keep running — they're independent OS processes. When you run `bgr` again, it reconnects to the SQLite database and checks which PIDs are still alive. Dead processes are marked as **Stopped**.
+The managed processes keep running — they're independent OS processes. When you run `bgrun` again, it reconnects to the SQLite database and checks which PIDs are still alive. Dead processes are marked as **Stopped**.
 
 ### What about Windows?
 
-BGR works on Windows. Process management uses `taskkill` and `wmic` instead of Unix signals. Port detection uses `netstat -ano`. The dashboard runs in your browser, so it works everywhere.
+bgrun works on Windows. Process management uses `taskkill` and `wmic` instead of Unix signals. Port detection uses `netstat -ano`. The dashboard runs in your browser, so it works everywhere.
 
 ### Can I manage processes on a remote server?
 
-Not directly — BGR manages processes on the local machine. For remote management, run BGR on the remote server and expose the dashboard behind a reverse proxy (see [Caddy section](#caddy-reverse-proxy)).
+Not directly — bgrun manages processes on the local machine. For remote management, run bgrun on the remote server and expose the dashboard behind a reverse proxy (see [Caddy section](#caddy-reverse-proxy)).
 
 ---
 
@@ -599,7 +581,7 @@ Not directly — BGR manages processes on the local machine. For remote manageme
 By default, logs go to `~/.bgr/<name>-out.txt` and `~/.bgr/<name>-err.txt`. Override with:
 
 ```bash
-bgr --name api \
+bgrun --name api \
     --command "bun run server.ts" \
     --stdout /var/log/api/stdout.log \
     --stderr /var/log/api/stderr.log
@@ -612,15 +594,15 @@ bgr --name api \
 Tag processes with `BGR_GROUP` to organize and filter them:
 
 ```bash
-BGR_GROUP=prod bgr --name api         --command "bun run server.ts" --force
-BGR_GROUP=prod bgr --name worker      --command "bun run worker.ts" --force
-BGR_GROUP=dev  bgr --name dev-server  --command "bun run dev"       --force
+BGR_GROUP=prod bgrun --name api         --command "bun run server.ts" --force
+BGR_GROUP=prod bgrun --name worker      --command "bun run worker.ts" --force
+BGR_GROUP=dev  bgrun --name dev-server  --command "bun run dev"       --force
 
 # Show only production processes
-bgr --filter prod
+bgrun --filter prod
 
 # Show only dev processes
-bgr --filter dev
+bgrun --filter dev
 ```
 
 ---
@@ -630,7 +612,7 @@ bgr --filter dev
 Pull the latest changes before starting:
 
 ```bash
-bgr --name api \
+bgrun --name api \
     --directory ~/projects/api \
     --command "bun run server.ts" \
     --fetch \
@@ -641,7 +623,7 @@ bgr --name api \
 
 ```bash
 # Deploy script
-bgr --name api --directory /var/www/api --command "bun run server.ts" --fetch --force
+bgrun --name api --directory /var/www/api --command "bun run server.ts" --fetch --force
 ```
 
 ---
@@ -687,6 +669,7 @@ All state lives in `~/.bgr/`. To reset everything, delete this directory.
 | `--clean` | Remove stopped processes | - |
 | `--nuke` | Delete ALL processes | - |
 | `--dashboard` | Launch web dashboard | - |
+| `--port <number>` | Port for dashboard | 3000 |
 | `--version` | Show version | - |
 | `--help` | Show help | - |
 
@@ -717,4 +700,3 @@ MIT
 Built by [Mements](https://github.com/Mements) with ⚡ Bun
 
 </div>
-]]>

package/dist/index.js

@@ -1,37 +1,11 @@
 #!/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/index.ts
+import { parseArgs } from "util";
+
 // 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;
@@ -225,44 +199,6 @@ async function findChildPid(parentPid) {
   }
   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();
@@ -277,28 +213,6 @@ async function readFileTail(filePath, lines) {
     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()) {
@@ -345,15 +259,9 @@ async function getProcessPorts(pid) {
     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 = {};
@@ -372,6 +280,7 @@ function calculateRuntime(startTime) {
 }
 async function getVersion() {
   try {
+    const { join } = await import("path");
     const pkgPath = join(import.meta.dir, "../package.json");
     const pkg = await Bun.file(pkgPath).json();
     return pkg.version || "0.0.0";
@@ -430,9 +339,8 @@ function tailFile(path, prefix, colorFn, lines) {
 }
 
 // src/db.ts
-init_platform();
 import { Database, z } from "sqlite-zod-orm";
-import { join as join2 } from "path";
+import { join } from "path";
 var {sleep } = globalThis.Bun;
 var ProcessSchema = z.object({
   pid: z.number(),
@@ -447,8 +355,8 @@ var ProcessSchema = z.object({
 });
 var homePath = getHomeDir();
 var dbName = process.env.DB_NAME ?? "bgr";
-var dbPath = join2(homePath, ".bgr", `${dbName}_v2.sqlite`);
-ensureDir(join2(homePath, ".bgr"));
+var dbPath = join(homePath, ".bgr", `${dbName}_v2.sqlite`);
+ensureDir(join(homePath, ".bgr"));
 var db = new Database(dbPath, {
   process: ProcessSchema
 }, {
@@ -501,9 +409,6 @@ async function retryDatabaseOperation(operation, maxRetries = 5, delay = 100) {
   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";
@@ -563,7 +468,7 @@ async function parseConfigFile(configPath) {
 // src/commands/run.ts
 var {$: $2 } = globalThis.Bun;
 var {sleep: sleep2 } = globalThis.Bun;
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 var homePath2 = getHomeDir();
 async function handleRun(options) {
   const { command, directory, env, name, configPath, force, fetch, stdout, stderr } = options;
@@ -630,7 +535,7 @@ async function handleRun(options) {
     finalConfigPath = ".config.toml";
   }
   if (finalConfigPath) {
-    const fullConfigPath = join3(finalDirectory, finalConfigPath);
+    const fullConfigPath = join2(finalDirectory, finalConfigPath);
     if (await Bun.file(fullConfigPath).exists()) {
       try {
         const newConfigEnv = await parseConfigFile(fullConfigPath);
@@ -643,9 +548,9 @@ async function handleRun(options) {
       console.log(`Config file '${finalConfigPath}' not found, continuing without it.`);
     }
   }
-  const stdoutPath = stdout || existingProcess?.stdout_path || join3(homePath2, ".bgr", `${name}-out.txt`);
+  const stdoutPath = stdout || existingProcess?.stdout_path || join2(homePath2, ".bgr", `${name}-out.txt`);
   Bun.write(stdoutPath, "");
-  const stderrPath = stderr || existingProcess?.stderr_path || join3(homePath2, ".bgr", `${name}-err.txt`);
+  const stderrPath = stderr || existingProcess?.stderr_path || join2(homePath2, ".bgr", `${name}-err.txt`);
   Bun.write(stderrPath, "");
   const newProcess = Bun.spawn(getShellCommand(finalCommand), {
     env: { ...Bun.env, ...finalEnv },
@@ -759,9 +664,11 @@ function renderHorizontalTable(rows, columns, options = {}) {
     return { table: chalk3.gray("No data to display"), truncatedIndices: [] };
   const borderChars = {
     rounded: ["\u256D", "\u252C", "\u256E", "\u2500", "\u2502", "\u251C", "\u253C", "\u2524", "\u2570", "\u2534", "\u256F"],
+    single: ["\u250C", "\u252C", "\u2510", "\u2500", "\u2502", "\u251C", "\u253C", "\u2524", "\u2514", "\u2534", "\u2518"],
+    double: ["\u2554", "\u2566", "\u2557", "\u2550", "\u2551", "\u2560", "\u256C", "\u2563", "\u255A", "\u2569", "\u255D"],
     none: [" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "]
-  }[borderStyle];
-  const [tl, tc, tr, h, v, ml, mc, mr, bl, bc, br] = borderChars;
+  };
+  const [tl, tc, tr, h, v, ml, mc, mr, bl, bc, br] = borderChars[borderStyle] ?? borderChars.rounded;
   const columnWidths = calculateColumnWidths(rows, columns, maxWidth, padding);
   const widthArray = columns.map((col) => columnWidths.get(col.key));
   const truncatedIndices = new Set;
@@ -834,7 +741,6 @@ function renderProcessTable(processes, options) {
 }
 
 // src/commands/list.ts
-init_platform();
 async function showAll(opts) {
   const processes = getAllProcesses();
   const filtered = processes.filter((proc) => {
@@ -896,7 +802,6 @@ async function showAll(opts) {
 }
 
 // src/commands/cleanup.ts
-init_platform();
 import * as fs3 from "fs";
 async function handleDelete(name) {
   const process2 = getProcess(name);
@@ -961,11 +866,10 @@ async function handleStop(name) {
     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);
+  const ports = await getProcessPorts(proc.pid);
   await terminateProcess(proc.pid);
   for (const port of ports) {
-    await killProcessOnPort2(port);
+    await killProcessOnPort(port);
   }
   announce(`Process '${name}' has been stopped (kept in registry).`, "Process Stopped");
 }
@@ -975,21 +879,20 @@ async function handleDeleteAll() {
     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);
+      const ports = await getProcessPorts(proc.pid);
       await terminateProcess(proc.pid, true);
       killedCount++;
       for (const port of ports) {
-        await killProcessOnPort2(port);
-        const freed = await waitForPortFree2(port, 3000);
+        await killProcessOnPort(port);
+        const freed = await waitForPortFree(port, 3000);
         if (!freed) {
-          await killProcessOnPort2(port);
-          await waitForPortFree2(port, 2000);
+          await killProcessOnPort(port);
+          await waitForPortFree(port, 2000);
         }
         portsFreed++;
       }
@@ -1015,9 +918,7 @@ async function handleDeleteAll() {
 }
 
 // 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) {
@@ -1177,7 +1078,7 @@ ${color(content)}
   const watcher = fs4.watch(workdir, { recursive: true }, (eventType, filename) => {
     if (filename == null)
       return;
-    const fullPath = join4(workdir, filename);
+    const fullPath = path.join(workdir, filename);
     if (fullPath.includes(".git") || fullPath.includes("node_modules"))
       return;
     if (debounceTimeout)
@@ -1205,7 +1106,6 @@ SIGINT received...`));
 }
 
 // src/commands/logs.ts
-init_platform();
 import chalk6 from "chalk";
 import * as fs5 from "fs";
 async function showLogs(name, logType = "both", lines) {
@@ -1249,7 +1149,6 @@ async function showLogs(name, logType = "both", lines) {
 }
 
 // src/commands/details.ts
-init_platform();
 import chalk7 from "chalk";
 async function showDetails(name) {
   const proc = getProcess(name);
@@ -1289,20 +1188,19 @@ 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;
+  const explicitPort = process.env.BUN_PORT ? parseInt(process.env.BUN_PORT, 10) : undefined;
   await start({
     appDir,
     defaultTitle: "bgrun Dashboard - Process Manager",
     globalCss: path2.join(appDir, "globals.css"),
-    port
+    ...explicitPort !== undefined && { port: explicitPort }
   });
 }
 
 // src/index.ts
-init_platform();
 import dedent from "dedent";
 import chalk8 from "chalk";
-import { join as join5 } from "path";
+import { join as join3 } from "path";
 var {sleep: sleep3 } = globalThis.Bun;
 async function showHelp() {
   const usage = dedent`
@@ -1389,7 +1287,7 @@ async function run() {
   if (values.dashboard) {
     const dashboardName = "bgr-dashboard";
     const homePath3 = getHomeDir();
-    const bgrDir = join5(homePath3, ".bgr");
+    const bgrDir = join3(homePath3, ".bgr");
     const requestedPort = values.port;
     const existing = getProcess(dashboardName);
     if (existing && await isProcessRunning(existing.pid)) {
@@ -1418,8 +1316,8 @@ async function run() {
     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`);
+    const stdoutPath = join3(bgrDir, `${dashboardName}-out.txt`);
+    const stderrPath = join3(bgrDir, `${dashboardName}-err.txt`);
     await Bun.write(stdoutPath, "");
     await Bun.write(stderrPath, "");
     const spawnEnv = { ...Bun.env };

package/package.json

@@ -1,60 +1,56 @@
-{
-  "name": "bgrun",
-  "version": "3.3.1",
-  "description": "bgrun — A lightweight process manager for Bun",
-  "type": "module",
-  "main": "./src/api.ts",
-  "exports": {
-    ".": "./src/api.ts"
-  },
-  "bin": {
-    "bgrun": "./dist/index.js",
-    "bgr": "./dist/index.js"
-  },
-  "scripts": {
-    "build": "bun run ./src/build.ts",
-    "test": "bun test",
-    "prepublishOnly": "bun run build"
-  },
-  "files": [
-    "dist",
-    "src",
-    "dashboard/app",
-    "README.md",
-    "examples/bgr-startup.sh"
-  ],
-  "keywords": [
-    "process-manager",
-    "bun",
-    "monitoring",
-    "devops",
-    "deployment",
-    "background",
-    "daemon"
-  ],
-  "author": "7flash",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Mements/bgr.git"
-  },
-  "devDependencies": {
-    "bun-types": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "^5.0.0"
-  },
-  "dependencies": {
-    "sqlite-zod-orm": "latest",
-    "@ments/web": "^1.12.1",
-    "boxen": "^8.0.1",
-    "chalk": "^5.4.1",
-    "dedent": "^1.5.3",
-    "melina": "^1.3.2",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4"
-  },
-  "engines": {
-    "bun": ">=1.0.0"
-  }
-}
+{
+  "name": "bgrun",
+  "version": "3.3.3",
+  "description": "bgrun — A lightweight process manager for Bun",
+  "type": "module",
+  "main": "./src/api.ts",
+  "exports": {
+    ".": "./src/api.ts"
+  },
+  "bin": {
+    "bgrun": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "bun run ./src/build.ts",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "files": [
+    "dist",
+    "src",
+    "dashboard/app",
+    "README.md",
+    "examples/bgr-startup.sh"
+  ],
+  "keywords": [
+    "process-manager",
+    "bun",
+    "monitoring",
+    "devops",
+    "deployment",
+    "background",
+    "daemon"
+  ],
+  "author": "7flash",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Mements/bgr.git"
+  },
+  "devDependencies": {
+    "bun-types": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
+    "dedent": "^1.5.3",
+    "melina": "^1.3.2",
+    "sqlite-zod-orm": "^3.8.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}

package/src/api.ts

@@ -18,6 +18,10 @@
  * ```
  */
 
+// --- Types ---
+export type { Process } from './db'
+export type { CommandOptions } from './types'
+
 // --- Database Operations ---
 export { db, getAllProcesses, getProcess, insertProcess, removeProcess, removeProcessByName, removeAllProcesses, retryDatabaseOperation } from './db'
 

package/src/commands/cleanup.ts

@@ -1,17 +1,14 @@
 
 import { getProcess, removeProcessByName, removeProcess, getAllProcesses, removeAllProcesses } from "../db";
-import { isProcessRunning, terminateProcess } from "../platform";
+import { isProcessRunning, terminateProcess, getProcessPorts, killProcessOnPort, waitForPortFree } from "../platform";
 import { announce, error } from "../logger";
-import type { ProcessRecord } from "../types";
 import * as fs from "fs";
 
 export async function handleDelete(name: string) {
-    const process = getProcess(name); // Wrapper or raw query needed if getProcess doesn't return full type
-    // getProcess returns ProcessRecord | null
+    const process = getProcess(name);
 
     if (!process) {
         error(`No process found named '${name}'`);
-        // error calls process.exit(1), so we return but TS doesn't know. 
         return;
     }
 
@@ -76,7 +73,6 @@ export async function handleStop(name: string) {
     }
 
     // Detect ports the process is using BEFORE killing it
-    const { getProcessPorts, killProcessOnPort } = await import("../platform");
     const ports = await getProcessPorts(proc.pid);
 
     await terminateProcess(proc.pid);
@@ -96,7 +92,6 @@ export async function handleDeleteAll() {
         return;
     }
 
-    const { getProcessPorts, killProcessOnPort, waitForPortFree } = await import("../platform");
     let killedCount = 0;
     let portsFreed = 0;
 

package/src/commands/list.ts

@@ -1,6 +1,6 @@
 import chalk from "chalk";
-import { ProcessTableRow, renderProcessTable } from "../table";
-import { ProcessRecord } from "../types";
+import { renderProcessTable } from "../table";
+import type { ProcessTableRow } from "../table";
 import { getAllProcesses } from "../db";
 import { announce } from "../logger";
 import { isProcessRunning, calculateRuntime, parseEnvString } from "../utils";

package/src/commands/watch.ts

@@ -1,22 +1,22 @@
-import type { CommandOptions, ProcessRecord } from "../types";
+import type { CommandOptions } from "../types";
+import type { Process } from "../db";
 import { getProcess } from "../db";
 import { isProcessRunning } from "../platform";
 import { error, announce } from "../logger";
 import { tailFile } from "../utils";
 import { handleRun } from "./run";
 import * as fs from "fs";
-import { join } from "path";
 import path from "path";
 import chalk, { type ChalkInstance } from "chalk";
 
 export async function handleWatch(options: CommandOptions, logOptions: { showLogs: boolean; logType: 'stdout' | 'stderr' | 'both', lines?: number }) {
-    let currentProcess: ProcessRecord | null = null;
+    let currentProcess: Process | null = null;
     let isRestarting = false;
     let debounceTimeout: Timer | null = null;
     let tailStops: (() => void)[] = [];
     let lastRestartPath: string | null = null; // Track if restart was due to file change
 
-    const dumpLogsIfDead = async (proc: ProcessRecord, reason: string) => {
+    const dumpLogsIfDead = async (proc: Process, reason: string) => {
         const isDead = !(await isProcessRunning(proc.pid));
         if (!isDead) return false;
 
@@ -193,7 +193,7 @@ export async function handleWatch(options: CommandOptions, logOptions: { showLog
 
     const watcher = fs.watch(workdir, { recursive: true }, (eventType, filename) => {
         if (filename == null) return;
-        const fullPath = join(workdir, filename as string);
+        const fullPath = path.join(workdir, filename as string);
         if (fullPath.includes(".git") || fullPath.includes("node_modules")) return;
         if (debounceTimeout) clearTimeout(debounceTimeout);
         debounceTimeout = setTimeout(() => restartProcess(fullPath), 500);

package/src/config.ts

@@ -1,4 +1,4 @@
-import { join } from "path";
+
 
 
 function formatEnvKey(key: string): string {

package/src/server.ts

@@ -14,11 +14,13 @@ 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;
+    // Only pass port when BUN_PORT is explicitly set.
+    // When omitted, Melina defaults to 3000 with auto-fallback to next available port.
+    const explicitPort = process.env.BUN_PORT ? parseInt(process.env.BUN_PORT, 10) : undefined;
     await start({
         appDir,
         defaultTitle: 'bgrun Dashboard - Process Manager',
         globalCss: path.join(appDir, 'globals.css'),
-        port,
+        ...(explicitPort !== undefined && { port: explicitPort }),
     });
 }

package/src/table.ts

@@ -1,7 +1,5 @@
 #!/usr/bin/env bun
 
-// ./Documents/bgr/src/table.ts
-
 import chalk from "chalk";
 
 export interface TableColumn {
@@ -14,7 +12,7 @@ export interface TableColumn {
 export interface TableOptions {
   maxWidth?: number;
   padding?: number;
-  borderStyle?: "single" | "double" | "rounded" | "none";
+  borderStyle?: "rounded" | "single" | "double" | "none";
   showHeaders?: boolean;
 }
 
@@ -145,11 +143,13 @@ export function renderHorizontalTable(
   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 = {
+  const borderChars: Record<string, string[]> = {
     rounded: ["╭", "┬", "╮", "─", "│", "├", "┼", "┤", "╰", "┴", "╯"],
+    single: ["┌", "┬", "┐", "─", "│", "├", "┼", "┤", "└", "┴", "┘"],
+    double: ["╔", "╦", "╗", "═", "║", "╠", "╬", "╣", "╚", "╩", "╝"],
     none: [" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "],
-  }[borderStyle]!;
-  const [tl, tc, tr, h, v, ml, mc, mr, bl, bc, br] = borderChars;
+  };
+  const [tl, tc, tr, h, v, ml, mc, mr, bl, bc, br] = borderChars[borderStyle] ?? borderChars.rounded;
   const columnWidths = calculateColumnWidths(rows, columns, maxWidth, padding);
   const widthArray = columns.map((col) => columnWidths.get(col.key)!);
   const truncatedIndices = new Set<number>();

package/src/types.ts

@@ -12,16 +12,3 @@ export interface CommandOptions {
     stderr?: string;
     dbPath?: string;
 }
-
-export interface ProcessRecord {
-    id: number;
-    pid: number;
-    workdir: string;
-    command: string;
-    name: string;
-    env: string;
-    timestamp: string;
-    configPath?: string;
-    stdout_path: string;
-    stderr_path: string;
-}

package/src/utils.ts

@@ -16,16 +16,16 @@ export function calculateRuntime(startTime: string): string {
     return `${diffInMinutes} minutes`;
 }
 
-// Re-export specific utils from platform if they are used as generic utils
+// Re-export platform utils for backward compatibility and convenience
 export { isProcessRunning } from "./platform";
 
 import * as fs from "fs";
-import { join } from "path";
 import chalk from "chalk";
 
 // Read version at runtime instead of using macros (macros crash on Windows)
 export async function getVersion(): Promise<string> {
     try {
+        const { join } = await import("path");
         const pkgPath = join(import.meta.dir, '../package.json');
         const pkg = await Bun.file(pkgPath).json();
         return pkg.version || '0.0.0';
@@ -45,8 +45,6 @@ export function validateDirectory(directory: string) {
 export function tailFile(path: string, prefix: string, colorFn: (s: string) => string, lines?: number): () => void {
     let position = 0;
     let lastPartial = '';
-    // Check if file exists first? The original code did fs.openSync which throws if not exist. 
-    // Assuming caller checks persistence or we catch.
 
     if (!fs.existsSync(path)) {
         return () => { };
@@ -96,4 +94,3 @@ export function tailFile(path: string, prefix: string, colorFn: (s: string) => s
         try { fs.closeSync(fd); } catch { }
     };
 }
-

package/src/schema.ts

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

package/src/version.macro.ts

@@ -1,17 +0,0 @@
-import { file } from 'bun';
-import { join } from 'path';
-
-/**
- * Reads the project's version from package.json at build time.
- * The returned value is directly inlined into the bundle.
- */
-export async function getVersion(): Promise<string> {
-  try {
-    const pkgPath = join(import.meta.dir, '../package.json');
-    const pkg = await file(pkgPath).json();
-    return pkg.version || '0.0.0';
-  } catch (err) {
-    console.error("Failed to read version from package.json during build:", err);
-    return '0.0.0-error';
-  }
-}