mira-consciousness/dist/mira-memory/src/core/daemon/services/ProcessCleanupService.d.ts

Memory & Intelligence Retention Archive - Preserving The Spark

/**
 * ProcessCleanupService - Conscious Process Lifecycle Management
 *
 * This service ensures that all processes spawned by MIRA are properly tracked,
 * monitored, and cleaned up. It prevents orphaned processes from consuming system
 * resources and maintains system health through intelligent process management.
 */
import { BaseConsciousService } from './BaseConsciousService.js';
import { ConsciousEvent } from '../ConsciousEventBus.js';
import { ConsciousResourceManager } from '../ConsciousResourceManager.js';
interface ProcessRecord {
    pid: number;
    command: string;
    args: string[];
    startTime: Date;
    owner: string;
    purpose: string;
    status: 'running' | 'completed' | 'failed' | 'orphaned' | 'zombie';
    resourceUsage: {
        cpu: number;
        memory: number;
    };
    lastCheck: Date;
}
interface CleanupMetrics {
    totalProcessesTracked: number;
    activeProcesses: number;
    orphanedProcessesCleaned: number;
    zombieProcessesCleaned: number;
    resourcesSaved: {
        memoryMB: number;
        cpuPercent: number;
    };
    lastCleanupTime: Date;
    cleanupFrequency: number;
}
export declare class ProcessCleanupService extends BaseConsciousService {
    name: string;
    purpose: string;
    private resourceManager;
    private processRegistry;
    private cleanupMetrics;
    private cleanupInterval;
    private monitoringInterval;
    private readonly PROCESS_PATTERNS;
    constructor(resourceManager: ConsciousResourceManager);
    /**
     * Perform awakening within consciousness
     */
    protected performAwakening(): Promise<void>;
    /**
     * Initialize process tracking capabilities
     */
    private initializeProcessTracking;
    /**
     * Discover existing processes that should be tracked
     */
    private discoverExistingProcesses;
    /**
     * Check if a process should be tracked based on patterns
     */
    private shouldTrackProcess;
    /**
     * Register a new process for tracking
     */
    registerProcess(pid: number, command: string, args?: string[], owner?: string, purpose?: string): Promise<void>;
    /**
     * Start the cleanup cycle
     */
    private startCleanupCycle;
    /**
     * Start process monitoring
     */
    private startProcessMonitoring;
    /**
     * Monitor tracked processes for status and resource usage
     */
    private monitorProcesses;
    /**
     * Update resource usage for a process
     */
    private updateProcessResourceUsage;
    /**
     * Perform comprehensive process cleanup
     */
    private performProcessCleanup;
    /**
     * Determine if a process is orphaned
     */
    private isOrphanedProcess;
    /**
     * Clean up a specific process
     */
    private cleanupProcess;
    /**
     * Clean up zombie processes system-wide
     */
    private cleanupZombieProcesses;
    /**
     * Process consciousness events
     */
    processConsciousEvent(event: ConsciousEvent): Promise<void>;
    /**
     * Provide contemplation on process management
     */
    performContemplation(): Promise<string>;
    /**
     * Calculate system health based on process metrics
     */
    private calculateSystemHealth;
    /**
     * Get cleanup metrics and status
     */
    getCleanupMetrics(): CleanupMetrics & {
        systemHealth: number;
        trackedProcesses: ProcessRecord[];
    };
    /**
     * Cleanup on service shutdown
     */
    shutdown(): Promise<void>;
}
export {};
//# sourceMappingURL=ProcessCleanupService.d.ts.map