@masuidrive/procman 0.1.0

package/dist/src/process-manager/process-manager.d.ts.map

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

package/dist/src/process-manager/process-manager.js

@@ -0,0 +1,659 @@
+/**
+ * ProcessManager - Main process management facade
+ *
+ * This class provides a unified interface for process management,
+ * delegating operations to specialized components while maintaining
+ * backward compatibility with the existing API.
+ *
+ * ARCHITECTURE:
+ * - Uses composition pattern with specialized components
+ * - Maintains existing public interface for backward compatibility
+ * - Delegates operations to appropriate components
+ * - Acts as a facade for the underlying system
+ */
+import { EventEmitter } from 'events';
+import * as path from 'path';
+import * as os from 'os';
+import { ProcessLifecycleManagerImpl } from './process-lifecycle-manager.js';
+import { ProcessMonitorImpl } from './process-monitor.js';
+import { ProcessPersistenceImpl } from './process-persistence.js';
+import { ProcessGroupManagerImpl } from './process-group-manager.js';
+import { ManagedProcessInfo } from './managed-process-info.js';
+import { parseMemorySize } from '../shared/config.js';
+/**
+ * Type definition for batch operation results
+ */
+/**
+ * ProcessManager - Main facade class for process management
+ *
+ * This class coordinates all process management operations by delegating
+ * to specialized components while maintaining the existing public API.
+ */
+export class ProcessManager extends EventEmitter {
+    healthCheckInterval;
+    memoryCheckInterval;
+    // Core components
+    lifecycle;
+    monitor;
+    persistence;
+    groups;
+    // Process management state
+    processes = new Map();
+    processConfigs = new Map();
+    childProcesses = new Map();
+    isInitialized = false;
+    constructor(healthCheckInterval = 5000, memoryCheckInterval = 30000, persistenceFilePath) {
+        super();
+        this.healthCheckInterval = healthCheckInterval;
+        this.memoryCheckInterval = memoryCheckInterval;
+        // Initialize components with shared state
+        this.lifecycle = new ProcessLifecycleManagerImpl(this.processes, this.childProcesses);
+        this.monitor = new ProcessMonitorImpl(this.processes, this.childProcesses);
+        this.persistence = new ProcessPersistenceImpl(this.processes);
+        // Initialize persistence with default config
+        // Enhanced HOME detection: process.env.HOME || os.homedir()
+        const homeDir = process.env.HOME || os.homedir();
+        if (!homeDir && !persistenceFilePath) {
+            throw new Error('Unable to determine home directory for persistence path');
+        }
+        const defaultPersistencePath = persistenceFilePath ||
+            path.join(homeDir, '.masuidrive-procman', 'processes.json');
+        this.persistence.initialize({
+            filePath: defaultPersistencePath,
+            saveDelay: 1000,
+            enableBackup: true,
+        });
+        this.groups = new ProcessGroupManagerImpl(this.processes, {
+            startProcess: (name) => this.lifecycle.startProcess(name),
+            stopProcess: (name) => this.lifecycle.stopProcess(name),
+            restartProcess: (name) => this.lifecycle.restartProcess(name),
+        });
+        // Forward events from components
+        this.setupEventForwarding();
+        // Setup internal event handlers
+        this.setupInternalEventHandlers();
+    }
+    /**
+     * Set up event forwarding from components to maintain compatibility
+     */
+    setupEventForwarding() {
+        // Cast components to EventEmitter for event forwarding
+        const lifecycleEmitter = this.lifecycle;
+        const monitorEmitter = this.monitor;
+        const persistenceEmitter = this.persistence;
+        const groupsEmitter = this.groups;
+        // Forward lifecycle events
+        lifecycleEmitter.on('process:started', (name) => {
+            const processInfo = this.processes.get(name)?.getProcessInfo();
+            if (processInfo) {
+                this.emit('process:started', name, processInfo);
+            }
+        });
+        lifecycleEmitter.on('process:stopped', (name) => {
+            const processInfo = this.processes.get(name)?.getProcessInfo();
+            if (processInfo) {
+                this.emit('process:stopped', name, processInfo);
+            }
+        });
+        lifecycleEmitter.on('process:exit', (name, code, signal) => {
+            this.emit('process:exit', name, code, signal);
+        });
+        lifecycleEmitter.on('process:error', (name, error) => {
+            this.emit('process:error', name, error);
+        });
+        lifecycleEmitter.on('process:restart', (name) => {
+            this.emit('process:restart', name);
+        });
+        lifecycleEmitter.on('process:restarted', (name) => {
+            this.emit('process:restarted', name);
+        });
+        // Forward monitor events
+        monitorEmitter.on('process:memory-limit', (data) => {
+            this.emit('process:memory-limit', data.name, data.usage, data.limit);
+        });
+        monitorEmitter.on('process:unhealthy', (data) => {
+            this.emit('process:unhealthy', data.name, data.consecutiveFailures);
+        });
+        monitorEmitter.on('process:died', (data) => {
+            this.emit('process:died', data.name);
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        monitorEmitter.on('process:stats', (data) => {
+            this.emit('process:stats', data.name, data.stats);
+        });
+        // Forward persistence events
+        persistenceEmitter.on('persistence:saved', (filePath) => {
+            this.emit('persistence:saved', filePath);
+        });
+        persistenceEmitter.on('persistence:save-error', (error) => {
+            this.emit('persistence:save-error', error);
+        });
+        persistenceEmitter.on('persistence:loaded', (filePath, processCount) => {
+            this.emit('persistence:loaded', filePath, processCount);
+        });
+        persistenceEmitter.on('persistence:load-error', (error) => {
+            this.emit('persistence:load-error', error);
+        });
+        // Forward group events
+        groupsEmitter.on('namespace:operation-start', (namespace, operation) => {
+            this.emit('namespace:operation-start', namespace, operation);
+        });
+        groupsEmitter.on('namespace:operation-complete', 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (namespace, operation, results) => {
+            this.emit('namespace:operation-complete', namespace, operation, results);
+        });
+        groupsEmitter.on('batch:operation-start', (processNames, operation) => {
+            this.emit('batch:operation-start', processNames, operation);
+        });
+        groupsEmitter.on('batch:operation-complete', 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (operation, results) => {
+            this.emit('batch:operation-complete', operation, results);
+        });
+    }
+    /**
+     * Set up internal event handlers for process management
+     */
+    setupInternalEventHandlers() {
+        // Handle memory limit exceeded - trigger restart
+        this.on('process:memory-limit', async (name, usage, limit) => {
+            console.log(`Process '${name}' exceeded memory limit: ${Math.round(usage / 1024 / 1024)}MB > ${Math.round(limit / 1024 / 1024)}MB`);
+            const managedProcess = this.processes.get(name);
+            if (managedProcess && managedProcess.isAutoRestartEnabled()) {
+                console.log(`Auto-restarting process '${name}' due to memory limit`);
+                try {
+                    await this.restartProcess(name);
+                }
+                catch (error) {
+                    console.error(`Failed to restart process '${name}' after memory limit:`, error);
+                }
+            }
+        });
+    }
+    /**
+     * Static factory method to create ProcessManager with default components
+     */
+    static create(healthCheckInterval = 5000, memoryCheckInterval = 30000, persistenceFilePath) {
+        return new ProcessManager(healthCheckInterval, memoryCheckInterval, persistenceFilePath);
+    }
+    // ===== CONFIGURATION MANAGEMENT =====
+    /**
+     * Configure a process from app configuration
+     */
+    configureProcess(appConfig) {
+        // t_wada boundary principle: validate inputs at boundaries
+        if (appConfig == null) {
+            throw new Error('App configuration cannot be null or undefined');
+        }
+        if (typeof appConfig !== 'object') {
+            throw new Error('App configuration must be an object');
+        }
+        if (!appConfig.name || typeof appConfig.name !== 'string') {
+            throw new Error('App configuration must have a valid name');
+        }
+        // Validate process name contains only safe characters
+        const namePattern = /^[a-zA-Z0-9_-]+$/;
+        if (!namePattern.test(appConfig.name.trim())) {
+            throw new Error(`Invalid process name: "${appConfig.name}". Name must contain only alphanumeric characters, hyphens, and underscores`);
+        }
+        const processConfig = this.convertAppConfigToProcessConfig(appConfig);
+        this.processConfigs.set(appConfig.name, processConfig);
+        // Initialize process info if not exists
+        if (!this.processes.has(appConfig.name)) {
+            this.initializeProcess(appConfig.name);
+        }
+    }
+    /**
+     * Remove process configuration
+     */
+    removeProcessConfig(name) {
+        this.processConfigs.delete(name);
+    }
+    /**
+     * Get process configuration
+     */
+    getProcessConfig(name) {
+        return this.processConfigs.get(name);
+    }
+    // ===== PROCESS INFO ACCESS =====
+    /**
+     * Get process information
+     */
+    getProcessInfo(name) {
+        const processInfo = this.processes.get(name);
+        return processInfo?.getProcessInfo();
+    }
+    /**
+     * Get all process information
+     */
+    getAllProcessInfo() {
+        return Array.from(this.processes.values()).map((p) => p.getProcessInfo());
+    }
+    /**
+     * Get processes by namespace
+     */
+    getProcessesByNamespace(namespace) {
+        return Array.from(this.processes.values())
+            .filter((p) => p.getProcessInfo().namespace === namespace)
+            .map((p) => p.getProcessInfo());
+    }
+    /**
+     * Get process names by namespace
+     */
+    getProcessNamesByNamespace(namespace) {
+        return Array.from(this.processes.values())
+            .filter((p) => p.getProcessInfo().namespace === namespace)
+            .map((p) => p.getProcessInfo().name);
+    }
+    /**
+     * Get all namespaces
+     */
+    getNamespaces() {
+        const namespaces = new Set();
+        for (const processInfo of this.processes.values()) {
+            namespaces.add(processInfo.getProcessInfo().namespace || 'default');
+        }
+        return Array.from(namespaces).sort();
+    }
+    /**
+     * Get namespace status
+     */
+    getNamespaceStatus(namespace) {
+        const processes = this.getProcessesByNamespace(namespace);
+        const status = {
+            total: processes.length,
+            online: 0,
+            stopped: 0,
+            errored: 0,
+            starting: 0,
+            stopping: 0,
+        };
+        for (const process of processes) {
+            switch (process.status) {
+                case 'online':
+                    status.online++;
+                    break;
+                case 'stopped':
+                    status.stopped++;
+                    break;
+                case 'errored':
+                    status.errored++;
+                    break;
+                case 'starting':
+                    status.starting++;
+                    break;
+                case 'stopping':
+                    status.stopping++;
+                    break;
+            }
+        }
+        return status;
+    }
+    /**
+     * Get all process names
+     */
+    getProcessNames() {
+        return Array.from(this.processes.keys()).sort();
+    }
+    /**
+     * Check if process exists
+     */
+    hasProcess(name) {
+        return this.processes.has(name);
+    }
+    // ===== PROCESS LIFECYCLE MANAGEMENT =====
+    /**
+     * Initialize a process (create ManagedProcessInfo)
+     */
+    initializeProcess(name) {
+        if (this.processes.has(name)) {
+            return false;
+        }
+        const config = this.processConfigs.get(name);
+        if (!config) {
+            return false;
+        }
+        const processInfo = new ManagedProcessInfo(config);
+        this.processes.set(name, processInfo);
+        // Forward ManagedProcessInfo events
+        processInfo.on('start', () => {
+            this.emit('process:started', name, processInfo.getProcessInfo());
+        });
+        processInfo.on('stop', () => {
+            this.emit('process:stopped', name, processInfo.getProcessInfo());
+        });
+        processInfo.on('error', (error) => {
+            this.emit('process:error', name, error);
+        });
+        return true;
+    }
+    /**
+     * Remove a process
+     */
+    removeProcess(name) {
+        const processInfo = this.processes.get(name);
+        if (!processInfo) {
+            return false;
+        }
+        // Clean up and remove
+        processInfo.dispose();
+        this.processes.delete(name);
+        this.processConfigs.delete(name);
+        return true;
+    }
+    /**
+     * Start a process
+     */
+    async startProcess(name) {
+        // t_wada boundary principle: validate inputs at boundaries
+        if (name == null) {
+            throw new Error('Process name cannot be null or undefined');
+        }
+        if (typeof name !== 'string') {
+            throw new Error('Process name must be a string');
+        }
+        if (name.trim() === '') {
+            throw new Error('Process name cannot be empty');
+        }
+        const result = await this.lifecycle.startProcess(name);
+        if (!result.success) {
+            throw new Error(result.error || `Failed to start process: ${name}`);
+        }
+    }
+    /**
+     * Stop a process
+     */
+    async stopProcess(name) {
+        const result = await this.lifecycle.stopProcess(name);
+        if (!result.success) {
+            throw new Error(result.error || `Failed to stop process: ${name}`);
+        }
+    }
+    /**
+     * Restart a process
+     */
+    async restartProcess(name) {
+        const result = await this.lifecycle.restartProcess(name);
+        if (!result.success) {
+            throw new Error(result.error || `Failed to restart process: ${name}`);
+        }
+    }
+    // ===== BATCH OPERATIONS =====
+    /**
+     * Start multiple processes
+     */
+    async startProcesses(names) {
+        const result = await this.groups.startProcesses(names);
+        return result.results;
+    }
+    /**
+     * Stop multiple processes
+     */
+    async stopProcesses(names) {
+        const result = await this.groups.stopProcesses(names);
+        return result.results;
+    }
+    /**
+     * Restart multiple processes
+     */
+    async restartProcesses(names) {
+        const result = await this.groups.restartProcesses(names);
+        return result.results;
+    }
+    /**
+     * Start all processes in a namespace
+     */
+    async startNamespace(namespace) {
+        const result = await this.groups.startNamespace(namespace);
+        return result.results;
+    }
+    /**
+     * Stop all processes in a namespace
+     */
+    async stopNamespace(namespace) {
+        const result = await this.groups.stopNamespace(namespace);
+        return result.results;
+    }
+    /**
+     * Restart all processes in a namespace
+     */
+    async restartNamespace(namespace) {
+        const result = await this.groups.restartNamespace(namespace);
+        return result.results;
+    }
+    // ===== MONITORING MANAGEMENT =====
+    /**
+     * Start monitoring all processes
+     */
+    startMonitoring() {
+        this.monitor.startMonitoring({
+            healthCheckInterval: this.healthCheckInterval,
+            memoryCheckInterval: this.memoryCheckInterval,
+        });
+    }
+    /**
+     * Stop monitoring all processes
+     */
+    stopMonitoring() {
+        this.monitor.stopMonitoring();
+    }
+    // ===== AUTO-RESTART MANAGEMENT =====
+    /**
+     * Enable auto-restart for a process
+     */
+    enableAutoRestart(name) {
+        const processInfo = this.processes.get(name);
+        if (processInfo && 'enableAutoRestart' in processInfo) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            processInfo.enableAutoRestart();
+        }
+    }
+    /**
+     * Disable auto-restart for a process
+     */
+    disableAutoRestart(name) {
+        const processInfo = this.processes.get(name);
+        if (processInfo && 'disableAutoRestart' in processInfo) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            processInfo.disableAutoRestart();
+        }
+    }
+    /**
+     * Reset restart failures for a process
+     */
+    resetRestartFailures(name) {
+        const processInfo = this.processes.get(name);
+        if (processInfo && 'resetRestartFailures' in processInfo) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            processInfo.resetRestartFailures();
+        }
+    }
+    /**
+     * Get auto-restart status for a process
+     */
+    getAutoRestartStatus(name) {
+        const processInfo = this.processes.get(name);
+        if (!processInfo || !('getAutoRestartStatus' in processInfo)) {
+            return {
+                enabled: false,
+                consecutiveFailures: 0,
+            };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return processInfo.getAutoRestartStatus();
+    }
+    // ===== DEPENDENCY MANAGEMENT =====
+    /**
+     * Configure a process dependency
+     */
+    configureDependency(dependency) {
+        this.groups.configureDependency(dependency);
+    }
+    /**
+     * Remove a process dependency
+     */
+    removeDependency(name) {
+        this.groups.removeDependency(name);
+    }
+    /**
+     * Get process dependency
+     */
+    getDependency(name) {
+        return this.groups.getDependency(name);
+    }
+    /**
+     * Get all dependencies
+     */
+    getAllDependencies() {
+        return this.groups.getAllDependencies();
+    }
+    /**
+     * Resolve dependencies for a set of processes
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    resolveDependencies(names) {
+        return this.groups.resolveDependencies(names);
+    }
+    /**
+     * Start processes with dependencies
+     */
+    async startProcessesWithDependencies(processNames) {
+        // This is a placeholder for future implementation
+        // For now, just start processes in order
+        return this.startProcesses(processNames);
+    }
+    /**
+     * Start dependency monitoring
+     */
+    startDependencyMonitoring() {
+        // Placeholder for future implementation
+    }
+    /**
+     * Stop dependency monitoring
+     */
+    stopDependencyMonitoring() {
+        // Placeholder for future implementation
+    }
+    // ===== PERSISTENCE MANAGEMENT =====
+    /**
+     * Initialize the process manager
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        // Load persisted state
+        const persistedProcesses = await this.persistence.loadState();
+        // Restore process states
+        for (const persistedProcess of persistedProcesses) {
+            // Check if we have a configuration for this process
+            const processInfo = this.processes.get(persistedProcess.name);
+            if (processInfo) {
+                // Restore the state
+                processInfo.restoreState(persistedProcess);
+            }
+        }
+        this.isInitialized = true;
+    }
+    /**
+     * Save current state
+     */
+    async saveState() {
+        const processData = Array.from(this.processes.values()).map((p) => p.toJSON());
+        await this.persistence.saveState(processData);
+    }
+    /**
+     * Force save state immediately
+     */
+    async forceSaveState() {
+        const processData = Array.from(this.processes.values()).map((p) => p.toJSON());
+        await this.persistence.forceSaveState(processData);
+    }
+    /**
+     * Get persistence file path
+     */
+    getPersistenceFilePath() {
+        return this.persistence.getFilePath();
+    }
+    // ===== CLEANUP =====
+    /**
+     * Clean up all resources
+     */
+    async cleanup() {
+        // Stop monitoring
+        this.stopMonitoring();
+        // Save final state
+        await this.forceSaveState();
+        // Cleanup components
+        const cleanupPromises = [];
+        if ('cleanup' in this.lifecycle) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            cleanupPromises.push(this.lifecycle.cleanup());
+        }
+        if ('cleanup' in this.monitor) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            cleanupPromises.push(this.monitor.cleanup());
+        }
+        if ('cleanup' in this.persistence) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            cleanupPromises.push(this.persistence.cleanup());
+        }
+        if ('cleanup' in this.groups) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            cleanupPromises.push(this.groups.cleanup());
+        }
+        await Promise.all(cleanupPromises);
+        // Clean up processes
+        for (const processInfo of this.processes.values()) {
+            processInfo.dispose();
+        }
+        this.processes.clear();
+        this.processConfigs.clear();
+        this.isInitialized = false;
+    }
+    // ===== HELPER METHODS =====
+    /**
+     * Convert AppConfig to ProcessConfig
+     */
+    convertAppConfigToProcessConfig(appConfig) {
+        // Parse memory limit if specified
+        let max_memory_restart;
+        if (appConfig.max_memory_restart) {
+            const result = parseMemorySize(appConfig.max_memory_restart);
+            if (result.success && result.value) {
+                max_memory_restart = result.value;
+            }
+        }
+        const processConfig = {
+            name: appConfig.name,
+            script: appConfig.script,
+            cwd: appConfig.cwd || process.cwd(),
+            args: appConfig.args
+                ? appConfig.args.split(' ').filter((arg) => arg.length > 0)
+                : [],
+            namespace: appConfig.namespace || 'default',
+            instances: 1, // AppConfig doesn't have instances
+            autorestart: true, // Default to true for auto-restart
+            watch: false, // AppConfig doesn't have watch
+            max_memory_restart,
+            max_restarts: 10, // Default max restarts
+            min_uptime: 1000, // Default min uptime
+            restart_delay: 1000, // Default restart delay
+            note: appConfig.note,
+            env: {},
+        };
+        // Process environment variables (remove undefined values)
+        if (appConfig.env) {
+            for (const [key, value] of Object.entries(appConfig.env)) {
+                if (value !== undefined) {
+                    processConfig.env[key] = value;
+                }
+            }
+        }
+        return processConfig;
+    }
+}
+// Re-export types for backward compatibility
+export { ManagedProcessInfo, };
+//# sourceMappingURL=process-manager.js.map