bgrun 3.12.1 → 3.12.2

package/src/bgrun.test.ts

@@ -9,6 +9,13 @@
 import { describe, expect, test } from 'bun:test'
 import { parseEnvString, calculateRuntime } from './utils'
 import { stripAnsi, truncateString, truncatePath } from './table'
+import { detectPackageManager, formatDeployToolError } from './deploy'
+import { isProcessRunning } from './platform'
+import { mkdirSync, rmSync } from 'fs'
+
+// Use a test-specific database to avoid polluting real data
+process.env.BGRUN_DB = `bgrun-test-${Date.now()}.sqlite`
+import { addDependency, removeDependency, getDependencyGraph, getDependencies, getDependents, getStartOrder, removeAllDependencies } from './db'
 
 // ─── parseEnvString ─────────────────────────────────────
 
@@ -107,3 +114,167 @@ describe('truncatePath', () => {
         expect(result).toContain('…')
     })
 })
+
+// ─── detectPackageManager ───────────────────────────────
+
+// ─── isProcessRunning (Windows liveness fallback) ───────
+
+describe('isProcessRunning', () => {
+    test('returns true for the current process PID', async () => {
+        const alive = await isProcessRunning(process.pid)
+        expect(alive).toBe(true)
+    })
+
+    test('returns false for PID 0 (intentionally stopped)', async () => {
+        const alive = await isProcessRunning(0)
+        expect(alive).toBe(false)
+    })
+
+    test('returns false for a very high unlikely PID', async () => {
+        const alive = await isProcessRunning(999999)
+        expect(alive).toBe(false)
+    })
+
+    test('returns false for negative PID', async () => {
+        const alive = await isProcessRunning(-1)
+        expect(alive).toBe(false)
+    })
+})
+
+// ─── detectPackageManager ───────────────────────────────
+
+describe('formatDeployToolError', () => {
+    test('returns actionable message for missing binary', () => {
+        const msg = formatDeployToolError('pnpm', new Error('command not found: pnpm'))
+        expect(msg).toContain("requires 'pnpm'")
+        expect(msg).toContain('PATH')
+    })
+
+    test('preserves non-missing-binary failures', () => {
+        const msg = formatDeployToolError('npm', new Error('npm ci failed with exit code 1'))
+        expect(msg).toContain('Dependency install failed with npm')
+        expect(msg).toContain('exit code 1')
+    })
+})
+
+describe('detectPackageManager', () => {
+    test('returns null when no package.json exists', async () => {
+        const dir = `${process.cwd()}/tmp-no-package-${Date.now()}`
+        mkdirSync(dir, { recursive: true })
+        try {
+            expect(await detectPackageManager(dir)).toBeNull()
+        } finally {
+            rmSync(dir, { recursive: true, force: true })
+        }
+    })
+
+    test('prefers bun lockfiles', async () => {
+        const dir = `${process.cwd()}/tmp-bun-${Date.now()}`
+        mkdirSync(dir, { recursive: true })
+        try {
+            await Bun.write(`${dir}/package.json`, '{}')
+            await Bun.write(`${dir}/bun.lock`, '')
+            expect(await detectPackageManager(dir)).toBe('bun')
+        } finally {
+            rmSync(dir, { recursive: true, force: true })
+        }
+    })
+
+    test('detects pnpm, yarn, and npm lockfiles', async () => {
+        const base = `${process.cwd()}/tmp-pm-${Date.now()}`
+
+        const pnpmDir = `${base}-pnpm`
+        mkdirSync(pnpmDir, { recursive: true })
+        await Bun.write(`${pnpmDir}/package.json`, '{}')
+        await Bun.write(`${pnpmDir}/pnpm-lock.yaml`, '')
+        expect(await detectPackageManager(pnpmDir)).toBe('pnpm')
+
+        const yarnDir = `${base}-yarn`
+        mkdirSync(yarnDir, { recursive: true })
+        await Bun.write(`${yarnDir}/package.json`, '{}')
+        await Bun.write(`${yarnDir}/yarn.lock`, '')
+        expect(await detectPackageManager(yarnDir)).toBe('yarn')
+
+        const npmDir = `${base}-npm`
+        mkdirSync(npmDir, { recursive: true })
+        await Bun.write(`${npmDir}/package.json`, '{}')
+        await Bun.write(`${npmDir}/package-lock.json`, '{}')
+        expect(await detectPackageManager(npmDir)).toBe('npm')
+
+        rmSync(pnpmDir, { recursive: true, force: true })
+        rmSync(yarnDir, { recursive: true, force: true })
+        rmSync(npmDir, { recursive: true, force: true })
+    })
+
+    test('defaults to bun for package.json projects without a lockfile', async () => {
+        const dir = `${process.cwd()}/tmp-default-bun-${Date.now()}`
+        mkdirSync(dir, { recursive: true })
+        try {
+            await Bun.write(`${dir}/package.json`, '{}')
+            expect(await detectPackageManager(dir)).toBe('bun')
+        } finally {
+            rmSync(dir, { recursive: true, force: true })
+        }
+    })
+})
+
+// ─── Dependencies ───────────────────────────────────────
+
+describe('addDependency', () => {
+    test('adds a valid dependency', () => {
+        removeAllDependencies('web-server');
+        removeAllDependencies('database');
+        const ok = addDependency('web-server', 'database');
+        expect(ok).toBe(true);
+        expect(getDependencies('web-server')).toContain('database');
+    })
+
+    test('prevents self-dependency', () => {
+        expect(addDependency('api', 'api')).toBe(false);
+    })
+
+    test('prevents duplicate dependency', () => {
+        removeAllDependencies('app');
+        addDependency('app', 'db');
+        expect(addDependency('app', 'db')).toBe(false);
+    })
+
+    test('prevents circular dependency', () => {
+        removeAllDependencies('a');
+        removeAllDependencies('b');
+        removeAllDependencies('c');
+        addDependency('a', 'b');
+        addDependency('b', 'c');
+        // c -> a would create a cycle
+        expect(addDependency('c', 'a')).toBe(false);
+    })
+})
+
+describe('getDependencyGraph', () => {
+    test('returns full graph', () => {
+        removeAllDependencies('svc-a');
+        removeAllDependencies('svc-b');
+        addDependency('svc-a', 'svc-b');
+        const graph = getDependencyGraph();
+        expect(graph['svc-a']).toContain('svc-b');
+    })
+})
+
+describe('getDependents', () => {
+    test('finds processes that depend on a target', () => {
+        removeAllDependencies('frontend');
+        removeAllDependencies('backend');
+        addDependency('frontend', 'backend');
+        expect(getDependents('backend')).toContain('frontend');
+    })
+})
+
+describe('removeDependency', () => {
+    test('removes an existing dependency', () => {
+        removeAllDependencies('x');
+        addDependency('x', 'y');
+        expect(getDependencies('x')).toContain('y');
+        removeDependency('x', 'y');
+        expect(getDependencies('x')).not.toContain('y');
+    })
+})

package/src/db.ts

@@ -44,6 +44,14 @@ export const HistorySchema = z.object({
 
 export type History = z.infer<typeof HistorySchema> & { id: number };
 
+export const DependencySchema = z.object({
+    process_name: z.string(),     // the process that has the dependency
+    depends_on: z.string(),       // the process it depends on
+    created_at: z.string().default(() => new Date().toISOString()),
+});
+
+export type Dependency = z.infer<typeof DependencySchema> & { id: number };
+
 // =============================================================================
 // DATABASE INITIALIZATION
 // =============================================================================
@@ -72,11 +80,13 @@ export const db = new Database(dbPath, {
     process: ProcessSchema,
     template: TemplateSchema,
     history: HistorySchema,
+    dependency: DependencySchema,
 }, {
     indexes: {
         process: ['name', 'timestamp', 'pid'],
         template: ['name'],
         history: ['process_name', 'timestamp'],
+        dependency: ['process_name', 'depends_on'],
     },
 });
 
@@ -242,6 +252,138 @@ export function clearOldHistory(daysToKeep = 30) {
     return oldEntries.length;
 }
 
+// =============================================================================
+// DEPENDENCY FUNCTIONS
+// =============================================================================
+
+/** Get all dependencies for a process */
+export function getDependencies(processName: string): string[] {
+    return db.dependency.select()
+        .where({ process_name: processName })
+        .all()
+        .map(d => d.depends_on);
+}
+
+/** Get all processes that depend on a given process */
+export function getDependents(processName: string): string[] {
+    return db.dependency.select()
+        .where({ depends_on: processName })
+        .all()
+        .map(d => d.process_name);
+}
+
+/** Get the full dependency graph: { processName -> [dependsOn...] } */
+export function getDependencyGraph(): Record<string, string[]> {
+    const all = db.dependency.select().all();
+    const graph: Record<string, string[]> = {};
+    for (const dep of all) {
+        if (!graph[dep.process_name]) graph[dep.process_name] = [];
+        graph[dep.process_name].push(dep.depends_on);
+    }
+    return graph;
+}
+
+/** Add a dependency (process_name depends on depends_on) */
+export function addDependency(processName: string, dependsOn: string): boolean {
+    // Prevent self-dependency
+    if (processName === dependsOn) return false;
+    
+    // Prevent duplicates
+    const existing = db.dependency.select()
+        .where({ process_name: processName, depends_on: dependsOn })
+        .limit(1)
+        .get();
+    if (existing) return false;
+    
+    // Prevent circular dependencies
+    if (wouldCreateCycle(processName, dependsOn)) return false;
+    
+    db.dependency.insert({ process_name: processName, depends_on: dependsOn });
+    return true;
+}
+
+/** Remove a dependency */
+export function removeDependency(processName: string, dependsOn: string) {
+    const matches = db.dependency.select()
+        .where({ process_name: processName, depends_on: dependsOn })
+        .all();
+    for (const dep of matches) {
+        db.dependency.delete(dep.id);
+    }
+}
+
+/** Remove all dependencies for a process */
+export function removeAllDependencies(processName: string) {
+    const matches = db.dependency.select()
+        .where({ process_name: processName })
+        .all();
+    for (const dep of matches) {
+        db.dependency.delete(dep.id);
+    }
+}
+
+/** Check if adding processName -> dependsOn would create a cycle */
+function wouldCreateCycle(processName: string, dependsOn: string): boolean {
+    const graph = getDependencyGraph();
+    // Add the proposed edge temporarily
+    if (!graph[processName]) graph[processName] = [];
+    graph[processName].push(dependsOn);
+    
+    // DFS from dependsOn — if we can reach processName, it's a cycle
+    const visited = new Set<string>();
+    const stack = [dependsOn];
+    while (stack.length > 0) {
+        const current = stack.pop()!;
+        if (current === processName) return true;
+        if (visited.has(current)) continue;
+        visited.add(current);
+        for (const dep of (graph[current] || [])) {
+            stack.push(dep);
+        }
+    }
+    return false;
+}
+
+/** Get topological start order (processes with no deps first) */
+export function getStartOrder(): string[] {
+    const graph = getDependencyGraph();
+    const allProcesses = getAllProcesses().map(p => p.name);
+    const allNames = new Set(allProcesses);
+    
+    // Build in-degree map
+    const inDegree: Record<string, number> = {};
+    for (const name of allNames) inDegree[name] = 0;
+    for (const [proc, deps] of Object.entries(graph)) {
+        for (const dep of deps) {
+            if (allNames.has(dep)) {
+                inDegree[proc] = (inDegree[proc] || 0) + 1;
+            }
+        }
+    }
+    
+    // Kahn's algorithm
+    const queue: string[] = [];
+    for (const name of allNames) {
+        if ((inDegree[name] || 0) === 0) queue.push(name);
+    }
+    
+    const order: string[] = [];
+    while (queue.length > 0) {
+        queue.sort(); // stable alphabetical within same level
+        const current = queue.shift()!;
+        order.push(current);
+        // Find processes that depend on current
+        for (const [proc, deps] of Object.entries(graph)) {
+            if (deps.includes(current) && allNames.has(proc)) {
+                inDegree[proc]--;
+                if (inDegree[proc] === 0) queue.push(proc);
+            }
+        }
+    }
+    
+    return order;
+}
+
 // =============================================================================
 // DEBUG / INFO
 // =============================================================================

package/src/deploy.ts

@@ -0,0 +1,163 @@
+import { getProcess, getAllProcesses, addHistoryEntry } from './db';
+import { handleRun } from './commands/run';
+import { $ } from 'bun';
+
+export interface DeployResult {
+    name: string;
+    ok: boolean;
+    skipped?: boolean;
+    reason?: string;
+    pullOutput?: string;
+    installOutput?: string;
+    packageManager?: PackageManager;
+    installCommand?: string;
+    installAttempted?: boolean;
+}
+
+export type PackageManager = 'bun' | 'pnpm' | 'yarn' | 'npm' | null;
+
+export function formatDeployToolError(manager: Exclude<PackageManager, null>, error: unknown): string {
+    const raw = error instanceof Error ? error.message : String(error ?? 'Unknown error');
+    const lower = raw.toLowerCase();
+
+    if (
+        lower.includes('command not found') ||
+        lower.includes('not recognized as an internal or external command') ||
+        lower.includes('executable not found') ||
+        lower.includes('no such file or directory')
+    ) {
+        return `Deploy requires '${manager}', but it is not installed or not available on PATH.`;
+    }
+
+    return `Dependency install failed with ${manager}: ${raw}`;
+}
+
+function isInternalProcess(name: string): boolean {
+    return name === 'bgr-dashboard' || name === 'bgr-guard';
+}
+
+async function pathExists(path: string): Promise<boolean> {
+    return await Bun.file(path).exists();
+}
+
+async function isGitRepo(dir: string): Promise<boolean> {
+    return await pathExists(`${dir}/.git`) || await pathExists(`${dir}/.git/HEAD`);
+}
+
+export async function detectPackageManager(dir: string): Promise<PackageManager> {
+    const hasPackageJson = await pathExists(`${dir}/package.json`);
+    if (!hasPackageJson) return null;
+
+    if (await pathExists(`${dir}/bun.lock`) || await pathExists(`${dir}/bun.lockb`)) return 'bun';
+    if (await pathExists(`${dir}/pnpm-lock.yaml`)) return 'pnpm';
+    if (await pathExists(`${dir}/yarn.lock`)) return 'yarn';
+    if (await pathExists(`${dir}/package-lock.json`) || await pathExists(`${dir}/npm-shrinkwrap.json`)) return 'npm';
+
+    return 'bun';
+}
+
+function getInstallCommand(manager: Exclude<PackageManager, null>): string {
+    switch (manager) {
+        case 'bun': return 'bun install';
+        case 'pnpm': return 'pnpm install --frozen-lockfile';
+        case 'yarn': return 'yarn install --frozen-lockfile';
+        case 'npm': return 'npm ci';
+    }
+}
+
+async function installDependencies(dir: string): Promise<{ manager: PackageManager; output: string; command: string }> {
+    const manager = await detectPackageManager(dir);
+    if (!manager) return { manager: null, output: '', command: '' };
+
+    $.cwd(dir);
+    const command = getInstallCommand(manager);
+
+    try {
+        switch (manager) {
+            case 'bun':
+                return { manager, command, output: (await $`bun install`.text()).trim() };
+            case 'pnpm':
+                return { manager, command, output: (await $`pnpm install --frozen-lockfile`.text()).trim() };
+            case 'yarn':
+                return { manager, command, output: (await $`yarn install --frozen-lockfile`.text()).trim() };
+            case 'npm':
+                return { manager, command, output: (await $`npm ci`.text()).trim() };
+            default:
+                return { manager: null, output: '', command: '' };
+        }
+    } catch (error) {
+        throw new Error(formatDeployToolError(manager, error));
+    }
+}
+
+export async function deployProcess(name: string): Promise<DeployResult> {
+    const proc = getProcess(name);
+    if (!proc) {
+        return { name, ok: false, reason: `Process '${name}' not found` };
+    }
+
+    if (isInternalProcess(proc.name)) {
+        return { name, ok: false, skipped: true, reason: 'Internal bgrun process skipped' };
+    }
+
+    const dir = proc.workdir;
+    if (!(await isGitRepo(dir))) {
+        return { name, ok: false, skipped: true, reason: `'${dir}' is not a git repository` };
+    }
+
+    try {
+        $.cwd(dir);
+
+        const pullOutput = (await $`git pull`.text()).trim();
+
+        const install = await installDependencies(dir);
+        const installOutput = install.output;
+
+        await handleRun({
+            action: 'run',
+            name,
+            force: true,
+            remoteName: '',
+        });
+
+        addHistoryEntry(name, 'deploy', proc.pid, {
+            directory: dir,
+            installed: Boolean(install.manager),
+            packageManager: install.manager,
+            installCommand: install.command,
+        });
+
+        return {
+            name,
+            ok: true,
+            pullOutput,
+            installOutput,
+            packageManager: install.manager,
+            installCommand: install.command,
+            installAttempted: Boolean(install.manager),
+        };
+    } catch (e: any) {
+        return {
+            name,
+            ok: false,
+            reason: e?.message || String(e),
+        };
+    }
+}
+
+export async function deployAllProcesses(group?: string): Promise<DeployResult[]> {
+    const processes = getAllProcesses()
+        .filter(proc => !isInternalProcess(proc.name))
+        .filter(proc => !group || proc.group === group);
+
+    const seen = new Set<string>();
+    const results: DeployResult[] = [];
+
+    for (const proc of processes) {
+        if (seen.has(proc.name)) continue;
+        seen.add(proc.name);
+        results.push(await deployProcess(proc.name));
+    }
+
+    return results;
+}

package/src/index.ts

@@ -574,6 +574,15 @@ async function run() {
     return;
   }
 
+  // Explicit "list" command
+  if (name === 'list') {
+    await showAll({
+      json: values.json as boolean | undefined,
+      filter: values.filter as string | undefined
+    });
+    return;
+  }
+
   // List or Run or Details
   if (name) {
     if (!values.command && !values.directory) {

package/src/platform.ts

@@ -61,9 +61,19 @@ export async function isProcessRunning(pid: number, command?: string): Promise<b
       }
 
       if (isWindows()) {
-        // process.kill(pid, 0) — signal 0 checks existence without killing
-        // 100x faster than tasklist which hangs on some Windows systems
-        try { process.kill(pid, 0); return true; } catch { return false; }
+        // Fast path: signal 0 works for many native Windows/Bun invocations.
+        // But under MSYS/Git Bash or detached wrapper scenarios it can return
+        // false negatives for live Windows PIDs. Fall back to Get-Process so
+        // CLI, dashboard, and guard all agree on process liveness.
+        try {
+          process.kill(pid, 0);
+          return true;
+        } catch {
+          const output = psExec(
+            `Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id`
+          ).trim();
+          return output === String(pid);
+        }
       } else {
         const result = await $`ps -p ${pid}`.nothrow().text();
         return result.includes(`${pid}`);
@@ -632,14 +642,12 @@ export async function getProcessPorts(pid: number): Promise<number[]> {
         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 result = await $`lsof -Pan -p ${pid} -iTCP -sTCP:LISTEN`.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]));
-          }
+        const portMatch = line.match(/:(\d+)\s+\(LISTEN\)/);
+        if (portMatch) {
+          ports.add(parseInt(portMatch[1]));
         }
       }
       return Array.from(ports);