@revealui/core 0.0.1-pre.3 → 0.2.0

package/dist/monitoring/types.d.ts

@@ -0,0 +1,231 @@
+/**
+ * Process Health Monitoring Types
+ *
+ * TypeScript definitions for system health monitoring, process tracking,
+ * zombie detection, and alerting.
+ */
+/**
+ * Source of a tracked process
+ */
+export type ProcessSource = 'exec' | 'orchestration' | 'mcp' | 'ai-runtime' | 'dev-server' | 'database' | 'unknown';
+/**
+ * Status of a tracked process
+ */
+export type ProcessStatus = 'running' | 'completed' | 'failed' | 'zombie' | 'killed';
+/**
+ * Tracked process metadata
+ */
+export interface ProcessMetadata {
+    [key: string]: string | number | boolean | undefined;
+}
+/**
+ * Tracked process entry
+ */
+export interface TrackedProcess {
+    /** Process ID */
+    pid: number;
+    /** Command executed */
+    command: string;
+    /** Command arguments */
+    args: string[];
+    /** Process source */
+    source: ProcessSource;
+    /** Current status */
+    status: ProcessStatus;
+    /** Start timestamp */
+    startTime: number;
+    /** End timestamp (if completed/failed/killed) */
+    endTime?: number;
+    /** Exit code (if completed/failed) */
+    exitCode?: number;
+    /** Signal that killed process (if killed) */
+    signal?: string;
+    /** Custom metadata */
+    metadata?: ProcessMetadata;
+    /** Parent process ID */
+    ppid?: number;
+}
+/**
+ * Zombie process detection result
+ */
+export interface ZombieProcess {
+    /** Process ID */
+    pid: number;
+    /** Parent process ID */
+    ppid: number;
+    /** Command name */
+    command: string;
+    /** When zombie was first detected */
+    detectedAt: number;
+    /** Associated tracked process (if available) */
+    trackedProcess?: TrackedProcess;
+}
+/**
+ * Database pool metrics
+ */
+export interface PoolMetrics {
+    /** Total connections in pool */
+    totalCount: number;
+    /** Idle connections */
+    idleCount: number;
+    /** Waiting requests */
+    waitingCount: number;
+    /** Pool name/identifier */
+    name: string;
+}
+/**
+ * System health metrics
+ */
+export interface HealthMetrics {
+    /** System information */
+    system: {
+        /** Memory usage in MB */
+        memoryUsage: number;
+        /** CPU usage percentage */
+        cpuUsage: number;
+        /** Uptime in seconds */
+        uptime: number;
+        /** Platform */
+        platform: string;
+        /** Node.js version */
+        nodeVersion: string;
+    };
+    /** Process statistics */
+    processes: {
+        /** Active running processes */
+        active: number;
+        /** Zombie processes */
+        zombies: number;
+        /** Failed processes */
+        failed: number;
+        /** Process spawn rate (per minute) */
+        spawnRate: number;
+        /** Processes by source */
+        bySource: Record<ProcessSource, number>;
+    };
+    /** Database pool metrics */
+    database: {
+        /** REST database pools */
+        rest: PoolMetrics[];
+        /** Vector database pools */
+        vector: PoolMetrics[];
+    };
+    /** Recent zombie processes */
+    recentZombies: ZombieProcess[];
+    /** Active alerts */
+    alerts: Alert[];
+    /** Timestamp of metrics collection */
+    timestamp: number;
+}
+/**
+ * Alert severity level
+ */
+export type AlertLevel = 'warning' | 'critical';
+/**
+ * Alert metric type
+ */
+export type AlertMetric = 'zombies' | 'memory' | 'active_processes' | 'database_waiting' | 'spawn_rate';
+/**
+ * Alert definition
+ */
+export interface Alert {
+    /** Alert severity */
+    level: AlertLevel;
+    /** Metric that triggered alert */
+    metric: AlertMetric;
+    /** Human-readable message */
+    message: string;
+    /** Current value */
+    value: number;
+    /** Threshold that was exceeded */
+    threshold: number;
+    /** Timestamp when alert was triggered */
+    timestamp: number;
+}
+/**
+ * Alert threshold configuration
+ */
+export interface AlertThresholds {
+    zombies: {
+        warning: number;
+        critical: number;
+    };
+    memory: {
+        warning: number;
+        critical: number;
+    };
+    processes: {
+        active: {
+            warning: number;
+            critical: number;
+        };
+    };
+    database: {
+        waiting: {
+            warning: number;
+            critical: number;
+        };
+    };
+    spawnRate: {
+        warning: number;
+        critical: number;
+    };
+}
+/**
+ * Cleanup handler function
+ */
+export type CleanupHandler = () => void | Promise<void>;
+/**
+ * Cleanup handler registration
+ */
+export interface CleanupRegistration {
+    /** Handler ID */
+    id: string;
+    /** Handler function */
+    handler: CleanupHandler;
+    /** Priority (higher executes first) */
+    priority: number;
+    /** Handler description */
+    description: string;
+}
+/**
+ * Process registry statistics
+ */
+export interface RegistryStats {
+    /** Total processes tracked */
+    total: number;
+    /** Currently running */
+    running: number;
+    /** Completed successfully */
+    completed: number;
+    /** Failed */
+    failed: number;
+    /** Zombies detected */
+    zombies: number;
+    /** Killed by signal */
+    killed: number;
+    /** Processes by source */
+    bySource: Record<ProcessSource, number>;
+}
+/**
+ * Health monitoring configuration
+ */
+export interface MonitoringConfig {
+    /** Enable process monitoring */
+    enabled: boolean;
+    /** Zombie detection interval (ms) */
+    zombieDetectionInterval: number;
+    /** Health check interval (ms) */
+    healthCheckInterval: number;
+    /** Alert thresholds */
+    alertThresholds: AlertThresholds;
+    /** Maximum tracked processes to keep in history */
+    maxHistorySize: number;
+    /** Maximum zombies to track */
+    maxZombieHistory: number;
+}
+/**
+ * Default monitoring configuration
+ */
+export declare const DEFAULT_MONITORING_CONFIG: MonitoringConfig;
+//# sourceMappingURL=types.d.ts.map

package/dist/monitoring/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/monitoring/types.ts"],"names":[],"mappings":"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"}

package/dist/monitoring/types.js

@@ -0,0 +1,42 @@
+/**
+ * Process Health Monitoring Types
+ *
+ * TypeScript definitions for system health monitoring, process tracking,
+ * zombie detection, and alerting.
+ */
+/**
+ * Default monitoring configuration
+ */
+export const DEFAULT_MONITORING_CONFIG = {
+    enabled: process.env.ENABLE_PROCESS_MONITORING !== 'false',
+    zombieDetectionInterval: 30_000, // 30 seconds
+    healthCheckInterval: 5_000, // 5 seconds
+    alertThresholds: {
+        zombies: {
+            warning: 3,
+            critical: 5,
+        },
+        memory: {
+            warning: 512, // MB
+            critical: 1024, // MB
+        },
+        processes: {
+            active: {
+                warning: 50,
+                critical: 100,
+            },
+        },
+        database: {
+            waiting: {
+                warning: 5,
+                critical: 10,
+            },
+        },
+        spawnRate: {
+            warning: 20, // per minute
+            critical: 50, // per minute
+        },
+    },
+    maxHistorySize: 1000,
+    maxZombieHistory: 50,
+};

package/dist/monitoring/zombie-detector.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Zombie Process Detector
+ *
+ * Periodically scans for defunct (zombie) processes and attempts automatic cleanup.
+ * Zombie processes are dead processes that haven't been reaped by their parent.
+ */
+import type { ZombieProcess } from './types.js';
+/**
+ * Zombie detector class
+ */
+declare class ZombieDetector {
+    private interval;
+    private zombieHistory;
+    private enabled;
+    private detectionInterval;
+    private maxHistory;
+    private onZombieDetected?;
+    /**
+     * Start zombie detection
+     */
+    start(): void;
+    /**
+     * Stop zombie detection
+     */
+    stop(): void;
+    /**
+     * Perform a single scan for zombie processes
+     */
+    scan(): Promise<ZombieProcess[]>;
+    /**
+     * Attempt to clean up a zombie process
+     */
+    private attemptCleanup;
+    /**
+     * Add zombie to history
+     */
+    private addToHistory;
+    /**
+     * Get zombie history
+     */
+    getHistory(): ZombieProcess[];
+    /**
+     * Get current zombie count
+     */
+    getCount(): number;
+    /**
+     * Clear history
+     */
+    clearHistory(): void;
+    /**
+     * Set zombie detection callback
+     */
+    onZombie(callback: (zombie: ZombieProcess) => void): void;
+    /**
+     * Enable or disable detection
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if detection is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Check if detector is running
+     */
+    isRunning(): boolean;
+}
+/**
+ * Singleton instance
+ */
+export declare const zombieDetector: ZombieDetector;
+/**
+ * Convenience functions
+ */
+export declare function startZombieDetection(): void;
+export declare function stopZombieDetection(): void;
+export declare function scanForZombies(): Promise<ZombieProcess[]>;
+export declare function getZombieHistory(): ZombieProcess[];
+export declare function getZombieCount(): number;
+export declare function onZombieDetected(callback: (zombie: ZombieProcess) => void): void;
+export {};
+//# sourceMappingURL=zombie-detector.d.ts.map

package/dist/monitoring/zombie-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zombie-detector.d.ts","sourceRoot":"","sources":["../../src/monitoring/zombie-detector.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAK/C;;GAEG;AACH,cAAM,cAAc;IAClB,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,OAAO,CAA6C;IAC5D,OAAO,CAAC,iBAAiB,CAA4D;IACrF,OAAO,CAAC,UAAU,CAAqD;IACvE,OAAO,CAAC,gBAAgB,CAAC,CAAiC;IAE1D;;OAEG;IACH,KAAK,IAAI,IAAI;IAiBb;;OAEG;IACH,IAAI,IAAI,IAAI;IAQZ;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;IA6DtC;;OAEG;YACW,cAAc;IAkD5B;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;IACH,UAAU,IAAI,aAAa,EAAE;IAI7B;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,YAAY,IAAI,IAAI;IAIpB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,GAAG,IAAI;IAIzD;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAUlC;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,SAAS,IAAI,OAAO;CAGrB;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,gBAAuB,CAAA;AAElD;;GAEG;AAEH,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED,wBAAgB,cAAc,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC,CAEzD;AAED,wBAAgB,gBAAgB,IAAI,aAAa,EAAE,CAElD;AAED,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,GAAG,IAAI,CAEhF"}

package/dist/monitoring/zombie-detector.js

@@ -0,0 +1,231 @@
+/**
+ * Zombie Process Detector
+ *
+ * Periodically scans for defunct (zombie) processes and attempts automatic cleanup.
+ * Zombie processes are dead processes that haven't been reaped by their parent.
+ */
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { logger } from '../utils/logger-server.js';
+import { processRegistry } from './process-registry.js';
+import { DEFAULT_MONITORING_CONFIG } from './types.js';
+const execAsync = promisify(exec);
+/**
+ * Zombie detector class
+ */
+class ZombieDetector {
+    interval = null;
+    zombieHistory = [];
+    enabled = DEFAULT_MONITORING_CONFIG.enabled;
+    detectionInterval = DEFAULT_MONITORING_CONFIG.zombieDetectionInterval;
+    maxHistory = DEFAULT_MONITORING_CONFIG.maxZombieHistory;
+    onZombieDetected;
+    /**
+     * Start zombie detection
+     */
+    start() {
+        if (!this.enabled || this.interval)
+            return;
+        logger.info('Starting zombie process detector', {
+            interval: this.detectionInterval,
+        });
+        this.interval = setInterval(() => {
+            this.scan().catch((error) => {
+                logger.error('Zombie detection scan failed', { error });
+            });
+        }, this.detectionInterval);
+        // Prevent interval from keeping process alive
+        this.interval.unref();
+    }
+    /**
+     * Stop zombie detection
+     */
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+            logger.info('Stopped zombie process detector');
+        }
+    }
+    /**
+     * Perform a single scan for zombie processes
+     */
+    async scan() {
+        if (!this.enabled)
+            return [];
+        try {
+            // Use ps to find defunct processes
+            // Format: PID PPID COMMAND STATE
+            const { stdout } = await execAsync("ps axo pid,ppid,comm,state | grep -E ' (Z|z)' || true");
+            const zombies = [];
+            if (stdout.trim()) {
+                const lines = stdout.trim().split('\n');
+                for (const line of lines) {
+                    const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+[Zz]/);
+                    if (match?.[1] && match[2] && match[3]) {
+                        const pid = parseInt(match[1], 10);
+                        const ppid = parseInt(match[2], 10);
+                        const command = match[3];
+                        const zombie = {
+                            pid,
+                            ppid,
+                            command,
+                            detectedAt: Date.now(),
+                            trackedProcess: processRegistry.get(pid),
+                        };
+                        zombies.push(zombie);
+                        // Mark in registry
+                        processRegistry.markZombie(pid);
+                        // Add to history
+                        this.addToHistory(zombie);
+                        // Log detection
+                        logger.warn('Zombie process detected', {
+                            pid,
+                            ppid,
+                            command,
+                        });
+                        // Attempt cleanup
+                        await this.attemptCleanup(zombie);
+                        // Notify callback
+                        if (this.onZombieDetected) {
+                            this.onZombieDetected(zombie);
+                        }
+                    }
+                }
+            }
+            return zombies;
+        }
+        catch (error) {
+            logger.error('Failed to scan for zombie processes', { error });
+            return [];
+        }
+    }
+    /**
+     * Attempt to clean up a zombie process
+     */
+    async attemptCleanup(zombie) {
+        try {
+            // Zombies can't be killed directly - need to signal parent to reap them
+            // Try sending SIGCHLD to parent process
+            logger.info('Attempting zombie cleanup by signaling parent', {
+                zombie: zombie.pid,
+                parent: zombie.ppid,
+            });
+            // Check if parent exists
+            const { stdout: parentExists } = await execAsync(`ps -p ${zombie.ppid} -o pid= || true`);
+            if (!parentExists.trim()) {
+                logger.warn('Zombie parent process does not exist', {
+                    zombie: zombie.pid,
+                    parent: zombie.ppid,
+                });
+                return false;
+            }
+            // Send SIGCHLD to parent
+            process.kill(zombie.ppid, 'SIGCHLD');
+            // Wait a moment and check if zombie is gone
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            const { stdout: zombieStillExists } = await execAsync(`ps -p ${zombie.pid} -o state= || true`);
+            if (!zombieStillExists.trim()) {
+                logger.info('Zombie process successfully reaped', {
+                    pid: zombie.pid,
+                });
+                return true;
+            }
+            logger.warn('Zombie process persists after cleanup attempt', {
+                pid: zombie.pid,
+                ppid: zombie.ppid,
+            });
+            return false;
+        }
+        catch (error) {
+            logger.error('Failed to cleanup zombie process', {
+                zombie: zombie.pid,
+                error,
+            });
+            return false;
+        }
+    }
+    /**
+     * Add zombie to history
+     */
+    addToHistory(zombie) {
+        this.zombieHistory.unshift(zombie);
+        // Trim history
+        if (this.zombieHistory.length > this.maxHistory) {
+            this.zombieHistory = this.zombieHistory.slice(0, this.maxHistory);
+        }
+    }
+    /**
+     * Get zombie history
+     */
+    getHistory() {
+        return [...this.zombieHistory];
+    }
+    /**
+     * Get current zombie count
+     */
+    getCount() {
+        return processRegistry.getZombies().length;
+    }
+    /**
+     * Clear history
+     */
+    clearHistory() {
+        this.zombieHistory = [];
+    }
+    /**
+     * Set zombie detection callback
+     */
+    onZombie(callback) {
+        this.onZombieDetected = callback;
+    }
+    /**
+     * Enable or disable detection
+     */
+    setEnabled(enabled) {
+        this.enabled = enabled;
+        if (!enabled && this.interval) {
+            this.stop();
+        }
+        else if (enabled && !this.interval) {
+            this.start();
+        }
+    }
+    /**
+     * Check if detection is enabled
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Check if detector is running
+     */
+    isRunning() {
+        return this.interval !== null;
+    }
+}
+/**
+ * Singleton instance
+ */
+export const zombieDetector = new ZombieDetector();
+/**
+ * Convenience functions
+ */
+export function startZombieDetection() {
+    zombieDetector.start();
+}
+export function stopZombieDetection() {
+    zombieDetector.stop();
+}
+export function scanForZombies() {
+    return zombieDetector.scan();
+}
+export function getZombieHistory() {
+    return zombieDetector.getHistory();
+}
+export function getZombieCount() {
+    return zombieDetector.getCount();
+}
+export function onZombieDetected(callback) {
+    zombieDetector.onZombie(callback);
+}

package/dist/nextjs/index.d.ts

@@ -0,0 +1,4 @@
+export { getRevealUI } from './utilities.js';
+export type { WithRevealUIOptions } from './withRevealUI.js';
+export { withRevealUI } from './withRevealUI.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/nextjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/nextjs/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,YAAY,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/nextjs/index.js

@@ -0,0 +1,3 @@
+// RevealUI Next.js integration
+export { getRevealUI } from './utilities.js';
+export { withRevealUI } from './withRevealUI.js';

package/dist/nextjs/utilities.d.ts

@@ -0,0 +1,5 @@
+import type { Config, RevealUIInstance } from '../types/index.js';
+export declare function getRevealUI(options: {
+    config: Config;
+}): Promise<RevealUIInstance>;
+//# sourceMappingURL=utilities.d.ts.map

package/dist/nextjs/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/nextjs/utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAKjE,wBAAsB,WAAW,CAAC,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAexF"}

package/dist/nextjs/utilities.js

@@ -0,0 +1,16 @@
+import { getRevealUI as getRevealUICore } from '../config/runtime.js';
+let revealInstance = null;
+let configInstance = null;
+export async function getRevealUI(options) {
+    // In development, always create a new instance to support HMR
+    if (process.env.NODE_ENV === 'development') {
+        revealInstance = null;
+        configInstance = null;
+    }
+    if (revealInstance && configInstance === options.config) {
+        return revealInstance;
+    }
+    revealInstance = await getRevealUICore({ config: options.config });
+    configInstance = options.config;
+    return revealInstance;
+}

package/dist/nextjs/withRevealUI.d.ts

@@ -0,0 +1,20 @@
+import type { NextConfig } from 'next';
+export interface WithRevealUIOptions {
+    /** Path to the RevealUI config file (relative to Next.js project root) */
+    configPath?: string;
+    /** Whether to enable admin UI */
+    admin?: boolean;
+    /** Admin route path */
+    adminRoute?: string;
+    /** API route path */
+    apiRoute?: string;
+}
+/**
+ * Next.js configuration wrapper for RevealUI
+ * Provides webpack aliases, environment variables, and build configuration
+ *
+ * Sets up `@revealui/config` alias to import the RevealUI config file.
+ * The alias works with both Webpack (Next.js < 15) and Turbopack (Next.js 16+).
+ */
+export declare function withRevealUI(nextConfig?: NextConfig, options?: WithRevealUIOptions): NextConfig;
+//# sourceMappingURL=withRevealUI.d.ts.map

package/dist/nextjs/withRevealUI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withRevealUI.d.ts","sourceRoot":"","sources":["../../src/nextjs/withRevealUI.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAOtC,MAAM,WAAW,mBAAmB;IAClC,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,iCAAiC;IACjC,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,uBAAuB;IACvB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,qBAAqB;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,UAAU,GAAE,UAAe,EAC3B,OAAO,GAAE,mBAAwB,GAChC,UAAU,CAgMZ"}