@masuidrive/procman 0.1.1 → 0.2.0

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

@@ -19,10 +19,10 @@ 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
- */
+import { validateAppConfig, convertAppConfigToProcessConfig, } from './process-config.js';
+import { setupEventForwarding, setupInternalEventHandlers, } from './process-event-forwarding.js';
+import * as ProcessInfoQueries from './process-info-queries.js';
+import * as BatchOps from './process-batch-operations.js';
 /**
  * ProcessManager - Main facade class for process management
  *
@@ -51,7 +51,6 @@ export class ProcessManager extends EventEmitter {
         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');
@@ -69,107 +68,9 @@ export class ProcessManager extends EventEmitter {
             restartProcess: (name) => this.lifecycle.restartProcess(name),
         });
         // Forward events from components
-        this.setupEventForwarding();
+        setupEventForwarding(this, this.processes, this.lifecycle, this.monitor, this.persistence, this.groups);
         // 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);
-                }
-            }
-        });
+        setupInternalEventHandlers(this, this.processes, (name) => this.restartProcess(name));
     }
     /**
      * Static factory method to create ProcessManager with default components
@@ -178,134 +79,46 @@ export class ProcessManager extends EventEmitter {
         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);
+        validateAppConfig(appConfig);
+        const processConfig = 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
-     */
+    // ===== PROCESS INFO ACCESS (delegated to ProcessInfoQueries) =====
     getProcessInfo(name) {
-        const processInfo = this.processes.get(name);
-        return processInfo?.getProcessInfo();
+        return ProcessInfoQueries.getProcessInfo(this.processes, name);
     }
-    /**
-     * Get all process information
-     */
     getAllProcessInfo() {
-        return Array.from(this.processes.values()).map((p) => p.getProcessInfo());
+        return ProcessInfoQueries.getAllProcessInfo(this.processes);
     }
-    /**
-     * Get processes by namespace
-     */
     getProcessesByNamespace(namespace) {
-        return Array.from(this.processes.values())
-            .filter((p) => p.getProcessInfo().namespace === namespace)
-            .map((p) => p.getProcessInfo());
+        return ProcessInfoQueries.getProcessesByNamespace(this.processes, namespace);
     }
-    /**
-     * Get process names by namespace
-     */
     getProcessNamesByNamespace(namespace) {
-        return Array.from(this.processes.values())
-            .filter((p) => p.getProcessInfo().namespace === namespace)
-            .map((p) => p.getProcessInfo().name);
+        return ProcessInfoQueries.getProcessNamesByNamespace(this.processes, namespace);
     }
-    /**
-     * 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();
+        return ProcessInfoQueries.getNamespaces(this.processes);
     }
-    /**
-     * 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;
+        return ProcessInfoQueries.getNamespaceStatus(this.processes, namespace);
     }
-    /**
-     * Get all process names
-     */
     getProcessNames() {
-        return Array.from(this.processes.keys()).sort();
+        return ProcessInfoQueries.getProcessNames(this.processes);
     }
-    /**
-     * Check if process exists
-     */
     hasProcess(name) {
-        return this.processes.has(name);
+        return ProcessInfoQueries.hasProcess(this.processes, name);
     }
     // ===== PROCESS LIFECYCLE MANAGEMENT =====
-    /**
-     * Initialize a process (create ManagedProcessInfo)
-     */
     initializeProcess(name) {
         if (this.processes.has(name)) {
             return false;
@@ -316,7 +129,6 @@ export class ProcessManager extends EventEmitter {
         }
         const processInfo = new ManagedProcessInfo(config);
         this.processes.set(name, processInfo);
-        // Forward ManagedProcessInfo events
         processInfo.on('start', () => {
             this.emit('process:started', name, processInfo.getProcessInfo());
         });
@@ -328,25 +140,17 @@ export class ProcessManager extends EventEmitter {
         });
         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');
         }
@@ -361,250 +165,147 @@ export class ProcessManager extends EventEmitter {
             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
-     */
+    // ===== BATCH OPERATIONS (delegated to BatchOps) =====
     async startProcesses(names) {
-        const result = await this.groups.startProcesses(names);
-        return result.results;
+        return BatchOps.startProcesses(this.groups, names);
     }
-    /**
-     * Stop multiple processes
-     */
     async stopProcesses(names) {
-        const result = await this.groups.stopProcesses(names);
-        return result.results;
+        return BatchOps.stopProcesses(this.groups, names);
     }
-    /**
-     * Restart multiple processes
-     */
     async restartProcesses(names) {
-        const result = await this.groups.restartProcesses(names);
-        return result.results;
+        return BatchOps.restartProcesses(this.groups, names);
     }
-    /**
-     * Start all processes in a namespace
-     */
     async startNamespace(namespace) {
-        const result = await this.groups.startNamespace(namespace);
-        return result.results;
+        return BatchOps.startNamespace(this.groups, namespace);
     }
-    /**
-     * Stop all processes in a namespace
-     */
     async stopNamespace(namespace) {
-        const result = await this.groups.stopNamespace(namespace);
-        return result.results;
+        return BatchOps.stopNamespace(this.groups, namespace);
     }
-    /**
-     * Restart all processes in a namespace
-     */
     async restartNamespace(namespace) {
-        const result = await this.groups.restartNamespace(namespace);
-        return result.results;
+        return BatchOps.restartNamespace(this.groups, namespace);
     }
     // ===== 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();
+        if (processInfo) {
+            processInfo.setAutoRestartEnabled(true);
         }
     }
-    /**
-     * 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();
+        if (processInfo) {
+            processInfo.setAutoRestartEnabled(false);
         }
     }
-    /**
-     * 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
+        if (processInfo) {
             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,
-            };
+        if (!processInfo) {
+            return { enabled: false, consecutiveFailures: 0 };
         }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return processInfo.getAutoRestartStatus();
+        return {
+            enabled: processInfo.isAutoRestartEnabled(),
+            consecutiveFailures: processInfo.getConsecutiveFailures(),
+        };
     }
-    // ===== DEPENDENCY MANAGEMENT =====
-    /**
-     * Configure a process dependency
-     */
+    // ===== DEPENDENCY MANAGEMENT (delegated to BatchOps) =====
     configureDependency(dependency) {
-        this.groups.configureDependency(dependency);
+        BatchOps.configureDependency(this.groups, dependency);
     }
-    /**
-     * Remove a process dependency
-     */
     removeDependency(name) {
-        this.groups.removeDependency(name);
+        BatchOps.removeDependency(this.groups, name);
     }
-    /**
-     * Get process dependency
-     */
     getDependency(name) {
-        return this.groups.getDependency(name);
+        return BatchOps.getDependency(this.groups, name);
     }
-    /**
-     * Get all dependencies
-     */
     getAllDependencies() {
-        return this.groups.getAllDependencies();
+        return BatchOps.getAllDependencies(this.groups);
     }
-    /**
-     * Resolve dependencies for a set of processes
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     resolveDependencies(names) {
-        return this.groups.resolveDependencies(names);
+        return BatchOps.resolveDependencies(this.groups, 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());
-        }
+        const cleanupIfAvailable = (component) => {
+            if ('cleanup' in component &&
+                typeof component.cleanup ===
+                    'function') {
+                return component.cleanup();
+            }
+            return undefined;
+        };
+        const cleanupPromises = [
+            this.lifecycle,
+            this.monitor,
+            this.persistence,
+            this.groups,
+        ]
+            .map(cleanupIfAvailable)
+            .filter(Boolean);
         await Promise.all(cleanupPromises);
-        // Clean up processes
         for (const processInfo of this.processes.values()) {
             processInfo.dispose();
         }
@@ -612,48 +313,7 @@ export class ProcessManager extends EventEmitter {
         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 { validateAppConfig, convertAppConfigToProcessConfig, } from './process-config.js';
 export { ManagedProcessInfo, };
 //# sourceMappingURL=process-manager.js.map