bgrun 3.12.12 → 3.12.14

package/src/commands/run.ts

@@ -1,217 +0,0 @@
-import type { CommandOptions } from "../types";
-import { getProcess, removeProcessByName, retryDatabaseOperation, insertProcess } from "../db";
-import { isProcessRunning, terminateProcess, getHomeDir, getShellCommand, killProcessOnPort, findChildPid, getProcessPorts, waitForPortFree, psExec } from "../platform";
-import { error, announce } from "../logger";
-import { validateDirectory, parseEnvString } from "../utils";
-import { parseConfigFile } from "../config";
-import { $ } from "bun";
-import { sleep } from "bun";
-import { join } from "path";
-import { createMeasure } from "measure-fn";
-
-const homePath = getHomeDir();
-const run = createMeasure('run');
-
-export async function handleRun(options: CommandOptions) {
-    const { command, directory, env, name, configPath, force, fetch, stdout, stderr } = options;
-
-    const existingProcess = name ? getProcess(name) : null;
-
-    // Auto-start unmet dependencies before starting this process
-    if (name && existingProcess) {
-        const { getUnmetDeps } = await import('../deps');
-        const unmet = await getUnmetDeps(name);
-        if (unmet.length > 0) {
-            await run.measure(`Start ${unmet.length} dependencies for "${name}"`, async () => {
-                for (const depName of unmet) {
-                    const depProc = getProcess(depName);
-                    if (depProc) {
-                        announce(`📦 Starting dependency "${depName}" for "${name}"`, 'Dependency');
-                        await handleRun({ action: 'run', name: depName, force: true, remoteName: '' });
-                    }
-                }
-            });
-        }
-    }
-
-    if (existingProcess) {
-        const finalDirectory = directory || existingProcess.workdir;
-        validateDirectory(finalDirectory);
-        $.cwd(finalDirectory);
-
-        if (fetch) {
-            if (!require('fs').existsSync(require('path').join(finalDirectory, '.git'))) {
-                error(`Cannot --fetch: '${finalDirectory}' is not a Git repository.`);
-            }
-            await run.measure(`Git fetch "${name}"`, async () => {
-                try {
-                    await $`git fetch origin`;
-                    const localHash = (await $`git rev-parse HEAD`.text()).trim();
-                    const remoteHash = (await $`git rev-parse origin/$(git rev-parse --abbrev-ref HEAD)`.text()).trim();
-
-                    if (localHash !== remoteHash) {
-                        await $`git pull origin $(git rev-parse --abbrev-ref HEAD)`;
-                        announce("📥 Pulled latest changes", "Git Update");
-                    }
-                } catch (err) {
-                    error(`Failed to pull latest changes: ${err}`);
-                }
-            });
-        }
-
-        const isRunning = await isProcessRunning(existingProcess.pid);
-        if (isRunning && !force) {
-            error(`Process '${name}' is currently running. Use --force to restart.`);
-        }
-
-        // Detect ports BEFORE killing so we can clean them up
-        let detectedPorts: number[] = [];
-        if (isRunning) {
-            detectedPorts = await getProcessPorts(existingProcess.pid);
-        }
-
-        if (isRunning) {
-            await run.measure(`Terminate "${name}" (PID ${existingProcess.pid})`, async () => {
-                await terminateProcess(existingProcess.pid);
-                announce(`🔥 Terminated existing process '${name}'`, "Process Terminated");
-            });
-        }
-
-        // Kill anything still on the ports the old process was using
-        if (detectedPorts.length > 0) {
-            await run.measure(`Port cleanup [${detectedPorts.join(', ')}]`, async () => {
-                for (const port of detectedPorts) {
-                    await killProcessOnPort(port);
-                }
-                for (const port of detectedPorts) {
-                    const freed = await waitForPortFree(port, 5000);
-                    if (!freed) {
-                        await killProcessOnPort(port);
-                        await waitForPortFree(port, 3000);
-                    }
-                }
-            });
-        }
-
-        // Zombie sweep: kill any remaining bun processes matching this command
-        // This catches orphaned children that survived taskkill when the parent shell exited
-        // IMPORTANT: Exclude the current bgrun process and dashboard to avoid self-kill
-        const cmdToMatch = existingProcess.command;
-        if (cmdToMatch) {
-            await run.measure('Zombie sweep', async () => {
-                try {
-                    const cmdKeyword = cmdToMatch.split(' ')[1] || cmdToMatch;
-                    // Skip sweep if keyword is too generic (would match unrelated processes)
-                    const GENERIC_KEYWORDS = ['dev', 'run', 'start', 'serve', 'build', 'test'];
-                    if (GENERIC_KEYWORDS.includes(cmdKeyword.toLowerCase())) {
-                        return; // Too dangerous — skip zombie sweep for generic commands
-                    }
-                    const currentPid = process.pid;
-                    const result = await psExec(
-                        `Get-CimInstance Win32_Process -Filter "Name='bun.exe'" | Where-Object { $_.CommandLine -match '${cmdKeyword.replace(/'/g, "''")}' -and $_.ProcessId -ne ${currentPid} } | Select-Object -ExpandProperty ProcessId`,
-                        3000
-                    );
-                    const zombiePids = result.split('\n')
-                        .map((l: string) => parseInt(l.trim()))
-                        .filter((n: number) => !isNaN(n) && n > 0 && n !== currentPid);
-                    for (const zPid of zombiePids) {
-                        await $`taskkill /F /T /PID ${zPid}`.nothrow().quiet();
-                    }
-                    if (zombiePids.length > 0) {
-                        announce(`🧹 Swept ${zombiePids.length} zombie process(es)`, 'Zombie Cleanup');
-                    }
-                } catch { /* best effort */ }
-            });
-        }
-
-        await retryDatabaseOperation(() =>
-            removeProcessByName(name!)
-        );
-    } else {
-        if (!directory || !name || !command) {
-            error("'directory', 'name', and 'command' parameters are required for new processes.");
-        }
-        validateDirectory(directory!);
-        $.cwd(directory!);
-    }
-
-    const finalCommand = command || existingProcess!.command;
-    const finalDirectory = directory || (existingProcess?.workdir!);
-    let finalEnv = env || (existingProcess ? parseEnvString(existingProcess.env) : {});
-    
-    // Default BGR_KEEP_ALIVE=true for new processes unless explicitly disabled
-    if (!('BGR_KEEP_ALIVE' in finalEnv)) {
-        finalEnv.BGR_KEEP_ALIVE = 'true';
-    }
-
-    let finalConfigPath: string | undefined | null;
-    if (configPath !== undefined) {
-        finalConfigPath = configPath;
-    } else if (existingProcess) {
-        finalConfigPath = existingProcess.configPath;
-    } else {
-        finalConfigPath = '.config.toml';
-    }
-
-    if (finalConfigPath) {
-        const fullConfigPath = join(finalDirectory, finalConfigPath);
-
-        if (await Bun.file(fullConfigPath).exists()) {
-            const configEnv = await run.measure(`Parse config "${finalConfigPath}"`, async () => {
-                try {
-                    return await parseConfigFile(fullConfigPath);
-                } catch (err: any) {
-                    console.warn(`Warning: Failed to parse config file ${finalConfigPath}: ${err.message}`);
-                    return null;
-                }
-            });
-            if (configEnv) {
-                finalEnv = { ...finalEnv, ...configEnv };
-                console.log(`Loaded config from ${finalConfigPath}`);
-            }
-        } else {
-            console.log(`Config file '${finalConfigPath}' not found, continuing without it.`);
-        }
-    }
-
-    const stdoutPath = stdout || existingProcess?.stdout_path || join(homePath, ".bgr", `${name}-out.txt`);
-    Bun.write(stdoutPath, '');
-    const stderrPath = stderr || existingProcess?.stderr_path || join(homePath, ".bgr", `${name}-err.txt`);
-    Bun.write(stderrPath, '');
-
-    const actualPid = await run.measure(`Spawn "${name}" → ${finalCommand}`, async () => {
-        const newProcess = Bun.spawn(getShellCommand(finalCommand!), {
-            env: { ...Bun.env, ...finalEnv },
-            cwd: finalDirectory,
-            stdout: Bun.file(stdoutPath),
-            stderr: Bun.file(stderrPath),
-        });
-
-        newProcess.unref();
-        // Give shell a moment to spawn child, then find PID before shell exits
-        await sleep(100);
-        // Find the actual child PID (shell wrapper exits immediately after spawning)
-        const pid = await findChildPid(newProcess.pid);
-        // Wait more for subprocess to initialize
-        await sleep(400);
-        return pid;
-    }) ?? 0;
-
-    await retryDatabaseOperation(() =>
-        insertProcess({
-            pid: actualPid,
-            workdir: finalDirectory,
-            command: finalCommand!,
-            name: name!,
-            env: Object.entries(finalEnv).map(([k, v]) => `${k}=${v}`).join(","),
-            configPath: finalConfigPath || '',
-            stdout_path: stdoutPath,
-            stderr_path: stderrPath,
-        })
-    );
-
-    announce(
-        `${existingProcess ? '🔄 Restarted' : '🚀 Launched'} process "${name}" with PID ${actualPid}`,
-        "Process Started"
-    );
-}

package/src/commands/watch.ts

@@ -1,223 +0,0 @@
-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 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: 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: Process, reason: string) => {
-        const isDead = !(await isProcessRunning(proc.pid));
-        if (!isDead) return false;
-
-        console.log(chalk.yellow(`💀 Process '${options.name}' died immediately after ${reason}—dumping logs:`));
-
-        const readAndDump = (path: string, color: ChalkInstance, label: string) => {
-            try {
-                if (fs.existsSync(path)) {
-                    const content = fs.readFileSync(path, 'utf8').trim();
-                    if (content) {
-                        console.log(`${color.bold(label)}:\n${color(content)}\n`);
-                    } else {
-                        console.log(`${color(label)}: (empty)`);
-                    }
-                }
-            } catch (err) {
-                console.warn(chalk.gray(`Could not read ${label} log: ${err}`));
-            }
-        };
-
-        if (logOptions.logType === 'both' || logOptions.logType === 'stdout') {
-            readAndDump(proc.stdout_path, chalk.white, '📄 Stdout');
-        }
-        if (logOptions.logType === 'both' || logOptions.logType === 'stderr') {
-            readAndDump(proc.stderr_path, chalk.red, '📄 Stderr');
-        }
-
-        return true;
-    };
-
-    const waitForLogReady = (logPath: string, timeoutMs = 5000): Promise<void> => {
-        return new Promise((resolve, reject) => {
-            const checkReady = (): boolean => {
-                try {
-                    if (fs.existsSync(logPath)) {
-                        const stat = fs.statSync(logPath);
-                        if (stat.size > 0) {
-                            return true;
-                        }
-                    }
-                } catch {
-                    // Ignore errors during check
-                }
-                return false;
-            };
-
-            if (checkReady()) {
-                resolve();
-                return;
-            }
-
-            const dir = path.dirname(logPath); // path module needs import. 'path' var name conflict?
-            // Need import path from 'path'
-            const filename = path.basename(logPath);
-            // ERROR: 'path' refers to module or var?
-            // I need to import { dirname, basename } from "path";
-
-            const watcher = fs.watch(dir, (eventType, changedFilename) => {
-                if (changedFilename === filename && eventType === 'change') {
-                    if (checkReady()) {
-                        watcher.close();
-                        resolve();
-                    }
-                }
-            });
-
-            setTimeout(() => {
-                watcher.close();
-                reject(new Error(`Log file ${logPath} did not become ready within ${timeoutMs}ms`));
-            }, timeoutMs);
-        });
-    };
-
-    const startTails = async (): Promise<(() => void)[]> => {
-        const stops: (() => void)[] = [];
-
-        if (!logOptions.showLogs || !currentProcess) return stops;
-
-        console.log(chalk.gray("\n" + '─'.repeat(50) + "\n"));
-
-        if (logOptions.logType === 'both' || logOptions.logType === 'stdout') {
-            console.log(chalk.green.bold(`📄 Tailing stdout for ${options.name}:`));
-            console.log(chalk.gray('═'.repeat(50)));
-            try {
-                await waitForLogReady(currentProcess.stdout_path);
-            } catch (err: any) {
-                console.warn(chalk.yellow(`⚠️  Stdout log not ready yet for ${options.name}—starting tail anyway: ${err.message}`));
-            }
-            const stop = tailFile(currentProcess.stdout_path, '', chalk.white, logOptions.lines);
-            stops.push(stop);
-        }
-
-        if (logOptions.logType === 'both' || logOptions.logType === 'stderr') {
-            console.log(chalk.red.bold(`📄 Tailing stderr for ${options.name}:`));
-            console.log(chalk.gray('═'.repeat(50)));
-            try {
-                await waitForLogReady(currentProcess.stderr_path);
-            } catch (err: any) {
-                console.warn(chalk.yellow(`⚠️  Stderr log not ready yet for ${options.name}—starting tail anyway: ${err.message}`));
-            }
-            const stop = tailFile(currentProcess.stderr_path, '', chalk.red, logOptions.lines);
-            stops.push(stop);
-        }
-
-        return stops;
-    };
-
-    const restartProcess = async (path?: string) => {
-        if (isRestarting) return;
-        isRestarting = true;
-        const restartReason = path ? `restart (change in ${path})` : 'initial start';
-        lastRestartPath = path || null;
-
-        tailStops.forEach(stop => stop());
-        tailStops = [];
-
-        console.clear();
-        announce(`🔄 Restarting process '${options.name}'... [${restartReason}]`, "Watch Mode");
-
-        try {
-            await handleRun({ ...options, force: true });
-            currentProcess = getProcess(options.name!); // Need to ensure name is string
-
-            if (!currentProcess) {
-                error(`Failed to find process '${options.name}' after restart.`);
-                return;
-            }
-
-            // Quick post-mortem if it died on startup
-            const died = await dumpLogsIfDead(currentProcess, restartReason);
-            if (died) {
-                if (lastRestartPath) {
-                    console.log(chalk.yellow(`⚠️  Compile error on change—pausing restarts until manual fix.`));
-                    return; // Avoid loop on bad code
-                } else {
-                    error(`Failed to start process '${options.name}'. Aborting watch mode.`);
-                    return;
-                }
-            }
-
-            tailStops = await startTails();
-        } catch (err) {
-            error(`Error during restart: ${err}`);
-        } finally {
-            isRestarting = false;
-            if (currentProcess) {
-                console.log(chalk.cyan(`\n👀 Watching for file changes in: ${currentProcess.workdir}`));
-            }
-        }
-    };
-
-    // Initial start
-    console.clear();
-    announce(`🚀 Starting initial process '${options.name}' in watch mode...`, "Watch Mode");
-    await handleRun(options);
-    currentProcess = getProcess(options.name!);
-
-    if (!currentProcess) {
-        error(`Could not start or find process '${options.name}'. Aborting watch mode.`);
-        return;
-    }
-
-    // Quick post-mortem if initial died
-    const initialDied = await dumpLogsIfDead(currentProcess, 'initial start');
-    if (initialDied) {
-        error(`Failed to start process '${options.name}'. Aborting watch mode.`);
-        return;
-    }
-
-    tailStops = await startTails();
-
-    const workdir = currentProcess.workdir;
-    console.log(chalk.cyan(`\n👀 Watching for file changes in: ${workdir}`));
-
-    const watcher = fs.watch(workdir, { recursive: true }, (eventType, filename) => {
-        if (filename == null) return;
-        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);
-    });
-
-    const cleanup = async () => {
-        console.log(chalk.magenta('\nSIGINT received...'));
-        watcher.close();
-        tailStops.forEach(stop => stop());
-        if (debounceTimeout) clearTimeout(debounceTimeout);
-
-        const procToKill = getProcess(options.name!);
-        if (procToKill) {
-            const isRunning = await isProcessRunning(procToKill.pid);
-            if (isRunning) {
-                // @note avoid "await terminateProcess(procToKill.pid)" because we can re-attach --watch mode to running process
-                console.log(`process ${procToKill.name} (PID: ${procToKill.pid}) still running`);
-            }
-        }
-        process.exit(0);
-    };
-
-    process.on('SIGINT', cleanup);
-    process.on('SIGTERM', cleanup);
-}
-
-

package/src/config.ts

@@ -1,37 +0,0 @@
-
-
-
-function formatEnvKey(key: string): string {
-    return key.toUpperCase().replace(/\./g, '_');
-}
-
-function flattenConfig(obj: any, prefix = ''): Record<string, string> {
-    return Object.keys(obj).reduce((acc: Record<string, string>, key: string) => {
-        const value = obj[key];
-        const newPrefix = prefix ? `${prefix}.${key}` : key;
-
-        if (Array.isArray(value)) {
-            value.forEach((item, index) => {
-                const indexedPrefix = `${newPrefix}.${index}`;
-                if (typeof item === 'object' && item !== null) {
-                    Object.assign(acc, flattenConfig(item, indexedPrefix));
-                } else {
-                    acc[formatEnvKey(indexedPrefix)] = String(item);
-                }
-            });
-        } else if (typeof value === 'object' && value !== null) {
-            Object.assign(acc, flattenConfig(value, newPrefix));
-        } else {
-            acc[formatEnvKey(newPrefix)] = String(value);
-        }
-        return acc;
-    }, {});
-}
-
-
-export async function parseConfigFile(configPath: string): Promise<Record<string, string>> {
-    // @note t suffix solves caching issue with env variables when using --watch flag
-    const importPath = `${configPath}?t=${Date.now()}`;
-    const parsedConfig = await import(importPath).then(m => m.default);
-    return flattenConfig(parsedConfig);
-}