aws-runtime-bridge 1.9.79 → 1.9.80

package/dist/services/agent-process-manager.js

@@ -1,796 +1,2 @@
-/**
- * Agent Process Manager
- *
- * Core lifecycle manager for agent processes on the bridge machine.
- * Provides comprehensive process management including creation, discovery,
- * monitoring, termination, and orphan reclamation capabilities.
- */
-import { execSync } from 'node:child_process';
-import os from 'node:os';
-import { createLogger } from '../utils/logger.js';
-import { getProcessRegistry } from './process-registry.js';
-import { isProcessRunning, findClaudeCodeProcesses, findOrphanProcessByAgentId, terminateProcessTree, waitForProcessExit, checkProcessHealth, } from './process-detector.js';
-import { loadPersistedSessions } from './terminal-persistence.js';
-const log = createLogger('agent-process-manager');
-/**
- * Agent Process Manager
- *
- * Manages the complete lifecycle of agent processes including:
- * - Creation: Register and verify new processes
- * - Discovery: Scan for managed, orphan, and unknown processes
- * - Monitoring: Health checks and heartbeat tracking
- * - Termination: Graceful stop with escalation strategy
- * - Orphan Reclamation: Adopt or terminate orphan processes
- */
-export class AgentProcessManager {
-    /**
-     * Private constructor - use getAgentProcessManager() for singleton access
-     */
-    constructor() {
-        this.registry = getProcessRegistry();
-    }
-    /**
-     * Get the singleton instance
-     */
-    static getInstance() {
-        if (AgentProcessManager.instance === null) {
-            AgentProcessManager.instance = new AgentProcessManager();
-        }
-        return AgentProcessManager.instance;
-    }
-    // =============================================================================
-    // CREATION PHASE
-    // =============================================================================
-    /**
-     * Start a new process and register it in the process registry
-     *
-     * Flow:
-     * 1. Register process with state='creating'
-     * 2. Verify it's running
-     * 3. Update state to 'running'
-     *
-     * @param config - Process configuration
-     * @throws Error if process registration fails or process is not running
-     */
-    async startProcess(config) {
-        const { agentId, sessionId, pid, mode, workspacePath, command } = config;
-        log.info(`[startProcess] Starting process: agentId=${agentId}, pid=${pid}, mode=${mode}`);
-        // Step 1: Register with 'creating' state
-        await this.registry.register({
-            agentId,
-            sessionId,
-            pid,
-            mode,
-            state: 'creating',
-            workspacePath,
-            command,
-        });
-        // Step 2: Verify process is running
-        log.debug(`[startProcess] Verifying process is running: pid=${pid}`);
-        const isRunning = isProcessRunning(pid);
-        if (!isRunning) {
-            log.error(`[startProcess] Process not running after registration: agentId=${agentId}, pid=${pid}`);
-            // Mark as terminated since it's not actually running
-            await this.registry.markTerminated(agentId);
-            throw new Error(`Process ${pid} is not running`);
-        }
-        // Step 3: Update state to 'running'
-        await this.registry.update(agentId, { state: 'running' });
-        await this.registry.updateHeartbeat(agentId);
-        log.info(`[startProcess] Process started successfully: agentId=${agentId}, pid=${pid}`);
-    }
-    // =============================================================================
-    // DISCOVERY PHASE
-    // =============================================================================
-    /**
-     * Discover all agent processes on the system
-     *
-     * Scans OS for all agent processes, compares with registry, and returns
-     * a list of discovered processes with their management status.
-     *
-     * @returns Array of discovered processes with management status
-     */
-    async discoverAllProcesses() {
-        log.debug('[discoverAllProcesses] Scanning for all agent processes');
-        // Get all processes from OS
-        const osProcesses = await findClaudeCodeProcesses();
-        const managedProcesses = this.registry.getAll();
-        const discovered = [];
-        // Create a set of managed PIDs for quick lookup
-        const managedPids = new Set(managedProcesses.map(p => p.pid));
-        const managedAgentIds = new Set(managedProcesses.map(p => p.agentId));
-        const pidToRecord = new Map(managedProcesses.map(p => [p.pid, p]));
-        // Check each OS process
-        for (const proc of osProcesses) {
-            const isManagedByPid = managedPids.has(proc.pid);
-            const isManagedByAgentId = proc.agentId && managedAgentIds.has(proc.agentId);
-            const recordByPid = pidToRecord.get(proc.pid);
-            // ★ 关键修复：当命令行中无法提取 agentId 但 PID 匹配注册表时，继承注册表的 agentId
-            const resolvedAgentId = proc.agentId || recordByPid?.agentId;
-            if (isManagedByPid || isManagedByAgentId) {
-                // Process is managed - find its record
-                const record = managedProcesses.find(p => p.pid === proc.pid || p.agentId === proc.agentId || p.agentId === resolvedAgentId);
-                discovered.push({
-                    ...proc,
-                    agentId: resolvedAgentId,
-                    managementStatus: 'managed',
-                    sessionId: record?.sessionId,
-                });
-            }
-            else if (resolvedAgentId) {
-                // Process has agentId but not in registry - it's an orphan
-                discovered.push({
-                    ...proc,
-                    agentId: resolvedAgentId,
-                    managementStatus: 'orphan',
-                });
-            }
-            else {
-                // Unknown agent process
-                discovered.push({
-                    ...proc,
-                    agentId: resolvedAgentId,
-                    managementStatus: 'unknown',
-                });
-            }
-        }
-        // Also check registry processes that might not be in OS scan
-        for (const record of managedProcesses) {
-            const found = discovered.find(p => p.pid === record.pid);
-            if (!found) {
-                // Process is in registry but not found in OS scan
-                const isAlive = isProcessRunning(record.pid);
-                discovered.push({
-                    pid: record.pid,
-                    command: record.command,
-                    agentId: record.agentId,
-                    managementStatus: isAlive ? 'managed' : 'orphan',
-                    sessionId: record.sessionId,
-                });
-            }
-        }
-        log.debug(`[discoverAllProcesses] Discovered ${discovered.length} processes: ` +
-            `${discovered.filter(p => p.managementStatus === 'managed').length} managed, ` +
-            `${discovered.filter(p => p.managementStatus === 'orphan').length} orphans, ` +
-            `${discovered.filter(p => p.managementStatus === 'unknown').length} unknown`);
-        return discovered;
-    }
-    // =============================================================================
-    // MONITORING PHASE
-    // =============================================================================
-    /**
-     * Check health of all registered processes
-     *
-     * Updates heartbeat and health status in registry for each managed process.
-     *
-     * @returns Map of agentId to health status
-     */
-    async healthCheckAll() {
-        log.debug('[healthCheckAll] Starting health check for all processes');
-        const results = new Map();
-        const managedProcesses = this.registry.getAll();
-        const promises = managedProcesses.map(async (record) => {
-            const health = await this.healthCheck(record.agentId);
-            results.set(record.agentId, health);
-            return health;
-        });
-        await Promise.all(promises);
-        log.debug(`[healthCheckAll] Completed health check for ${managedProcesses.length} processes`);
-        return results;
-    }
-    /**
-     * Check health of a single process
-     *
-     * @param agentId - Agent ID to check
-     * @returns Health status of the process
-     */
-    async healthCheck(agentId) {
-        const record = this.registry.get(agentId);
-        if (!record) {
-            log.warn(`[healthCheck] Process not found in registry: agentId=${agentId}`);
-            return {
-                pid: -1,
-                agentId,
-                alive: false,
-                cpu: 0,
-                memoryMB: 0,
-                status: 'dead',
-                lastUpdate: new Date(),
-            };
-        }
-        // Check process health
-        const health = await checkProcessHealth(record.pid, agentId);
-        // Update registry with health info
-        const healthStatus = {
-            cpu: health.cpu,
-            memoryMB: health.memoryMB,
-            status: health.status,
-        };
-        await this.registry.updateHealth(agentId, healthStatus);
-        if (health.alive) {
-            await this.registry.updateHeartbeat(agentId);
-        }
-        else if (record.state !== 'terminated' && record.state !== 'orphaned') {
-            // Process died unexpectedly - mark as orphaned
-            log.warn(`[healthCheck] Process died unexpectedly: agentId=${agentId}, pid=${record.pid}`);
-            await this.registry.markOrphaned(agentId);
-        }
-        return health;
-    }
-    // =============================================================================
-    // TERMINATION PHASE (with escalation strategy)
-    // =============================================================================
-    /**
-     * Stop a process with graceful escalation strategy
-     *
-     * Escalation levels:
-     * Level 1: SIGTERM → wait 3s
-     * Level 2: taskkill /T /F (Win) or kill -9 (Unix) → wait 3s
-     * Level 3: terminateProcessTree → wait 5s
-     * Level 4: mark as "unstoppable", return failure
-     *
-     * @param agentId - Agent ID to stop
-     * @returns Termination result with details
-     */
-    async stopProcess(agentId) {
-        const record = this.registry.get(agentId);
-        if (!record) {
-            return {
-                success: false,
-                agentId,
-                pid: -1,
-                level: 0,
-                terminated: 0,
-                failed: 0,
-                message: `Process not found in registry: ${agentId}`,
-            };
-        }
-        const { pid } = record;
-        log.info(`[stopProcess] Stopping process: agentId=${agentId}, pid=${pid}`);
-        // Check if already stopped
-        if (!isProcessRunning(pid)) {
-            log.info(`[stopProcess] Process already stopped: agentId=${agentId}, pid=${pid}`);
-            await this.registry.markTerminated(agentId);
-            return {
-                success: true,
-                agentId,
-                pid,
-                level: 0,
-                terminated: 1,
-                failed: 0,
-                message: 'Process was already stopped',
-            };
-        }
-        // Update state to 'stopping'
-        await this.registry.update(agentId, { state: 'stopping' });
-        // Level 1: SIGTERM
-        log.debug(`[stopProcess] Level 1: Sending SIGTERM to pid=${pid}`);
-        const sigtermResult = this.sendSigterm(pid);
-        if (sigtermResult) {
-            const exited = await waitForProcessExit(pid, 3000);
-            if (exited) {
-                await this.registry.markTerminated(agentId);
-                log.info(`[stopProcess] Process stopped at Level 1: agentId=${agentId}, pid=${pid}`);
-                return {
-                    success: true,
-                    agentId,
-                    pid,
-                    level: 1,
-                    terminated: 1,
-                    failed: 0,
-                    message: 'Process terminated with SIGTERM',
-                };
-            }
-        }
-        // Level 2: Force kill (taskkill /F or kill -9)
-        log.debug(`[stopProcess] Level 2: Force killing pid=${pid}`);
-        const forceKillResult = this.sendForceKill(pid);
-        if (forceKillResult) {
-            const exited = await waitForProcessExit(pid, 3000);
-            if (exited) {
-                await this.registry.markTerminated(agentId);
-                log.info(`[stopProcess] Process stopped at Level 2: agentId=${agentId}, pid=${pid}`);
-                return {
-                    success: true,
-                    agentId,
-                    pid,
-                    level: 2,
-                    terminated: 1,
-                    failed: 0,
-                    message: 'Process terminated with force kill',
-                };
-            }
-        }
-        // Level 3: Terminate process tree
-        log.debug(`[stopProcess] Level 3: Terminating process tree for pid=${pid}`);
-        const treeResult = await terminateProcessTree(pid);
-        // Wait for process tree to terminate
-        const treeExited = await waitForProcessExit(pid, 5000);
-        if (treeExited) {
-            await this.registry.markTerminated(agentId);
-            log.info(`[stopProcess] Process stopped at Level 3: agentId=${agentId}, pid=${pid}, terminated=${treeResult.terminated}, failed=${treeResult.failed}`);
-            return {
-                success: true,
-                agentId,
-                pid,
-                level: 3,
-                terminated: treeResult.terminated,
-                failed: treeResult.failed,
-                message: `Process tree terminated (${treeResult.terminated} processes)`,
-            };
-        }
-        // Level 4: Process is unstoppable
-        log.error(`[stopProcess] Level 4: Process is unstoppable: agentId=${agentId}, pid=${pid}`);
-        // Check final state
-        const finalStatus = isProcessRunning(pid) ? 'still running' : 'terminated';
-        if (finalStatus === 'terminated') {
-            await this.registry.markTerminated(agentId);
-            return {
-                success: true,
-                agentId,
-                pid,
-                level: 4,
-                terminated: 1,
-                failed: 0,
-                message: 'Process eventually terminated after all escalation levels',
-            };
-        }
-        return {
-            success: false,
-            agentId,
-            pid,
-            level: 4,
-            terminated: treeResult.terminated,
-            failed: treeResult.failed + 1,
-            message: 'Process could not be terminated - marked as unstoppable',
-        };
-    }
-    /**
-     * Send SIGTERM to a process
-     */
-    sendSigterm(pid) {
-        try {
-            process.kill(pid, 'SIGTERM');
-            return true;
-        }
-        catch (error) {
-            log.debug(`[sendSigterm] Failed to send SIGTERM to ${pid}:`, error);
-            return false;
-        }
-    }
-    /**
-     * Send force kill (SIGKILL on Unix, taskkill /F on Windows)
-     */
-    sendForceKill(pid) {
-        try {
-            if (os.platform() === 'win32') {
-                execSync(`taskkill /PID ${pid} /F`, { encoding: 'utf8', timeout: 5000, windowsHide: true });
-            }
-            else {
-                process.kill(pid, 'SIGKILL');
-            }
-            return true;
-        }
-        catch (error) {
-            log.debug(`[sendForceKill] Failed to force kill ${pid}:`, error);
-            return false;
-        }
-    }
-    /**
-     * Force kill a process immediately using terminateProcessTree
-     *
-     * This bypasses the graceful escalation and uses the most aggressive
-     * termination method immediately.
-     *
-     * @param agentId - Agent ID to force kill
-     * @returns Termination result
-     */
-    async forceKill(agentId) {
-        const record = this.registry.get(agentId);
-        if (!record) {
-            return {
-                success: false,
-                agentId,
-                pid: -1,
-                level: 0,
-                terminated: 0,
-                failed: 0,
-                message: `Process not found in registry: ${agentId}`,
-            };
-        }
-        const { pid } = record;
-        log.info(`[forceKill] Force killing process: agentId=${agentId}, pid=${pid}`);
-        // Update state
-        await this.registry.update(agentId, { state: 'stopping' });
-        // Direct process tree termination
-        const result = await terminateProcessTree(pid);
-        // Wait briefly for termination
-        const exited = await waitForProcessExit(pid, 2000);
-        if (exited) {
-            await this.registry.markTerminated(agentId);
-            log.info(`[forceKill] Process terminated: agentId=${agentId}, pid=${pid}`);
-            return {
-                success: true,
-                agentId,
-                pid,
-                level: 3, // Same level as tree termination
-                terminated: result.terminated,
-                failed: result.failed,
-                message: `Process force killed (${result.terminated} processes terminated)`,
-            };
-        }
-        log.error(`[forceKill] Process could not be force killed: agentId=${agentId}, pid=${pid}`);
-        return {
-            success: false,
-            agentId,
-            pid,
-            level: 3,
-            terminated: result.terminated,
-            failed: result.failed + 1,
-            message: 'Force kill failed - process may require manual intervention',
-        };
-    }
-    // =============================================================================
-    // ORPHAN RECLAMATION
-    // =============================================================================
-    /**
-     * Reclaim an orphan process by agentId
-     *
-     * Finds an orphan process by agentId, and either:
-     * - Adopts it into the registry (if found and not managed)
-     * - Terminates it (if adoption fails or process is problematic)
-     *
-     * @param agentId - Agent ID to find and reclaim
-     * @returns Reclamation result
-     */
-    async reclaimOrphan(agentId) {
-        log.info(`[reclaimOrphan] Attempting to reclaim orphan: agentId=${agentId}`);
-        // Check if already managed
-        if (this.registry.isManaged(agentId)) {
-            const record = this.registry.get(agentId);
-            if (!record) {
-                return { success: false, pid: -1, action: 'failed' };
-            }
-            log.info(`[reclaimOrphan] Process already managed: agentId=${agentId}, pid=${record.pid}`);
-            return {
-                success: true,
-                pid: record.pid,
-                action: 'adopted',
-            };
-        }
-        // Find orphan process
-        const orphan = await findOrphanProcessByAgentId(agentId);
-        if (!orphan) {
-            log.warn(`[reclaimOrphan] No orphan process found: agentId=${agentId}`);
-            return {
-                success: false,
-                pid: -1,
-                action: 'failed',
-            };
-        }
-        // Verify the process is still running
-        if (!isProcessRunning(orphan.pid)) {
-            log.warn(`[reclaimOrphan] Orphan process not running: agentId=${agentId}, pid=${orphan.pid}`);
-            return {
-                success: false,
-                pid: orphan.pid,
-                action: 'failed',
-            };
-        }
-        // Check if this PID is already managed by a different agent
-        if (this.registry.isManagedByPid(orphan.pid)) {
-            const existingRecord = this.registry.getByPid(orphan.pid);
-            if (!existingRecord) {
-                // Race condition - PID was just removed, proceed with adoption inline
-                try {
-                    const sessions = await loadPersistedSessions();
-                    const session = sessions.find(s => s.agentId === agentId);
-                    await this.registry.register({
-                        agentId,
-                        sessionId: session?.sessionId || `reclaimed-${Date.now()}`,
-                        pid: orphan.pid,
-                        mode: 'sdk',
-                        state: 'running',
-                        workspacePath: session?.workspacePath || orphan.cwd || '',
-                        command: orphan.command || session?.command || '',
-                        metadata: { reclaimedAt: new Date().toISOString(), wasOrphan: true },
-                    });
-                    return { success: true, pid: orphan.pid, action: 'adopted' };
-                }
-                catch {
-                    await terminateProcessTree(orphan.pid);
-                    return { success: false, pid: orphan.pid, action: 'terminated' };
-                }
-            }
-            log.warn(`[reclaimOrphan] PID already managed by different agent: pid=${orphan.pid}, existingAgentId=${existingRecord.agentId}`);
-            // If it's the same agentId, just update - this shouldn't happen but handle it
-            if (existingRecord.agentId === agentId) {
-                return {
-                    success: true,
-                    pid: orphan.pid,
-                    action: 'adopted',
-                };
-            }
-            // Different agent - this is a conflict, terminate the orphan
-            log.warn(`[reclaimOrphan] Terminating conflicting orphan: agentId=${agentId}, pid=${orphan.pid}`);
-            await terminateProcessTree(orphan.pid);
-            return {
-                success: true,
-                pid: orphan.pid,
-                action: 'terminated',
-            };
-        }
-        // Try to adopt the orphan - load persisted sessions for metadata
-        const sessions = await loadPersistedSessions();
-        const session = sessions.find(s => s.agentId === agentId);
-        try {
-            await this.registry.register({
-                agentId,
-                sessionId: session?.sessionId || `reclaimed-${Date.now()}`,
-                pid: orphan.pid,
-                mode: 'sdk',
-                state: 'running',
-                workspacePath: session?.workspacePath || orphan.cwd || '',
-                command: orphan.command || session?.command || '',
-                metadata: {
-                    reclaimedAt: new Date().toISOString(),
-                    wasOrphan: true,
-                },
-            });
-            log.info(`[reclaimOrphan] Successfully adopted orphan: agentId=${agentId}, pid=${orphan.pid}`);
-            return {
-                success: true,
-                pid: orphan.pid,
-                action: 'adopted',
-            };
-        }
-        catch (error) {
-            log.error(`[reclaimOrphan] Failed to adopt orphan: agentId=${agentId}, pid=${orphan.pid}`, error);
-            // If adoption fails, terminate the process
-            await terminateProcessTree(orphan.pid);
-            return {
-                success: false,
-                pid: orphan.pid,
-                action: 'terminated',
-            };
-        }
-    }
-    /**
-     * Scan all orphans and attempt to reclaim each
-     *
-     * @returns Array of reclamation results
-     */
-    async scanAndReclaimAll() {
-        log.info('[scanAndReclaimAll] Scanning for all orphan processes');
-        const results = [];
-        // Load persisted sessions to find potential orphans
-        const sessions = await loadPersistedSessions();
-        // Find all agent processes
-        const allProcesses = await findClaudeCodeProcesses();
-        const managedPids = new Set(this.registry.getAll().map(p => p.pid));
-        // Identify orphan processes
-        const orphans = allProcesses.filter(proc => {
-            // Not managed by PID
-            if (managedPids.has(proc.pid))
-                return false;
-            // Has agentId but not managed - this is an orphan
-            if (proc.agentId && !this.registry.isManaged(proc.agentId)) {
-                return true;
-            }
-            return false;
-        });
-        log.info(`[scanAndReclaimAll] Found ${orphans.length} orphan processes`);
-        // Try to reclaim each orphan
-        for (const orphan of orphans) {
-            if (!orphan.agentId) {
-                // No agentId - can't reclaim, just terminate
-                log.warn(`[scanAndReclaimAll] Orphan without agentId, terminating: pid=${orphan.pid}`);
-                await terminateProcessTree(orphan.pid);
-                results.push({
-                    agentId: 'unknown',
-                    pid: orphan.pid,
-                    action: 'terminated',
-                });
-                continue;
-            }
-            const result = await this.reclaimOrphan(orphan.agentId);
-            results.push({
-                agentId: orphan.agentId,
-                pid: result.pid,
-                action: result.action,
-            });
-        }
-        // Also check persisted sessions for orphans that might not be in the process list
-        for (const session of sessions) {
-            if (session.agentId && !this.registry.isManaged(session.agentId)) {
-                const orphanByAgentId = await findOrphanProcessByAgentId(session.agentId);
-                if (orphanByAgentId) {
-                    const result = await this.reclaimOrphan(session.agentId);
-                    // Avoid duplicates
-                    const existing = results.find(r => r.agentId === session.agentId);
-                    if (!existing) {
-                        results.push({
-                            agentId: session.agentId,
-                            pid: result.pid,
-                            action: result.action,
-                        });
-                    }
-                }
-            }
-        }
-        log.info(`[scanAndReclaimAll] Reclamation complete: ${results.length} processes processed`);
-        return results;
-    }
-    // =============================================================================
-    // REGISTRY INTEGRATION
-    // =============================================================================
-    /**
-     * Mark a process as orphaned in the registry
-     *
-     * @param agentId - Agent ID to mark
-     * @returns Whether the operation succeeded
-     */
-    async markOrphaned(agentId) {
-        log.info(`[markOrphaned] Marking process as orphaned: agentId=${agentId}`);
-        return await this.registry.markOrphaned(agentId);
-    }
-    /**
-     * Check if a process is managed
-     *
-     * @param agentId - Agent ID to check
-     * @returns Whether the process is managed
-     */
-    isManaged(agentId) {
-        return this.registry.isManaged(agentId);
-    }
-    /**
-     * Get all managed processes
-     *
-     * @returns Array of all managed process records
-     */
-    getAllManagedProcesses() {
-        return this.registry.getAll();
-    }
-    /**
-     * Get managed processes by state
-     *
-     * @param state - Process state to filter by
-     * @returns Array of process records matching the state
-     */
-    getManagedProcessesByState(state) {
-        return this.registry.getByState(state);
-    }
-    /**
-     * Find processes running on the machine that are NOT in registry
-     *
-     * @returns Array of unmanaged process info
-     */
-    async getUnmanagedProcesses() {
-        const allProcesses = await findClaudeCodeProcesses();
-        const managedPids = new Set(this.registry.getAll().map(p => p.pid));
-        const managedAgentIds = new Set(this.registry.getAll().map(p => p.agentId));
-        return allProcesses.filter(proc => {
-            // Not managed by PID
-            if (managedPids.has(proc.pid))
-                return false;
-            // Not managed by agentId
-            if (proc.agentId && managedAgentIds.has(proc.agentId))
-                return false;
-            return true;
-        });
-    }
-    /**
-     * Rebuild the process registry from persisted sessions (e.g. on startup)
-     *
-     * Scans all persisted sessions, checks which processes are still running,
-     * and registers them with appropriate state.
-     *
-     * @param sessions - Array of persisted session data
-     */
-    async rebuildRegistry(sessions) {
-        log.info(`[rebuildRegistry] Rebuilding registry from ${sessions.length} persisted sessions`);
-        // Clear existing registry
-        await this.registry.clear();
-        for (const session of sessions) {
-            if (!session.pid) {
-                log.debug(`[rebuildRegistry] Skipping session without PID: agentId=${session.agentId}`);
-                continue;
-            }
-            const isRunning = isProcessRunning(session.pid);
-            const state = isRunning ? 'running' : 'unknown';
-            try {
-                await this.registry.register({
-                    agentId: session.agentId,
-                    sessionId: session.sessionId,
-                    pid: session.pid,
-                    mode: 'sdk',
-                    state,
-                    workspacePath: session.workspacePath || '',
-                    command: session.command || '',
-                    metadata: {
-                        rebuiltAt: new Date().toISOString(),
-                        wasRunningOnStartup: isRunning,
-                    },
-                });
-                log.debug(`[rebuildRegistry] Registered: agentId=${session.agentId}, pid=${session.pid}, state=${state}`);
-            }
-            catch (error) {
-                log.warn(`[rebuildRegistry] Failed to register: agentId=${session.agentId}`, error);
-            }
-        }
-        const stats = this.registry.getStats();
-        log.info(`[rebuildRegistry] Registry rebuilt: total=${stats.total}, running=${stats.running}, unknown=${stats.unknown}`);
-    }
-    /**
-     * Get process statistics
-     *
-     * @returns Statistics for all managed processes
-     */
-    getStats() {
-        return this.registry.getStats();
-    }
-    /**
-     * Clean up stale registry entries
-     *
-     * Removes records where:
-     * - state is 'terminated' or 'unknown'
-     * - the process is no longer running
-     *
-     * This prevents dead entries from accumulating and inflating counts.
-     *
-     * @returns Number of entries removed
-     */
-    async cleanupStaleRegistry() {
-        const allRecords = this.registry.getAll();
-        let removed = 0;
-        for (const record of allRecords) {
-            if ((record.state === 'terminated' || record.state === 'unknown') &&
-                !isProcessRunning(record.pid)) {
-                await this.registry.remove(record.agentId);
-                removed++;
-                log.debug(`[cleanupStaleRegistry] Removed stale entry: agentId=${record.agentId}, pid=${record.pid}, state=${record.state}`);
-            }
-        }
-        if (removed > 0) {
-            log.info(`[cleanupStaleRegistry] Cleaned up ${removed} stale registry entries`);
-        }
-        return removed;
-    }
-    /**
-     * Remove a process from registry
-     *
-     * @param agentId - Agent ID to remove
-     * @returns Whether the operation succeeded
-     */
-    async removeProcess(agentId) {
-        log.info(`[removeProcess] Removing process from registry: agentId=${agentId}`);
-        return await this.registry.remove(agentId);
-    }
-    /**
-     * Get a single process record
-     *
-     * @param agentId - Agent ID to get
-     * @returns Process record or undefined
-     */
-    getProcess(agentId) {
-        return this.registry.get(agentId);
-    }
-    /**
-     * Get a process record by PID
-     *
-     * @param pid - Process ID to get
-     * @returns Process record or undefined
-     */
-    getProcessByPid(pid) {
-        return this.registry.getByPid(pid);
-    }
-}
-AgentProcessManager.instance = null;
-/**
- * Get the AgentProcessManager singleton instance
- *
- * @returns AgentProcessManager instance
- */
-export function getAgentProcessManager() {
-    return AgentProcessManager.getInstance();
-}
+import{execSync as I}from"node:child_process";import k from"node:os";import{createLogger as S}from"../utils/logger.js";import{getProcessRegistry as R}from"./process-registry.js";import{isProcessRunning as l,findClaudeCodeProcesses as y,findOrphanProcessByAgentId as $,terminateProcessTree as g,waitForProcessExit as m,checkProcessHealth as v}from"./process-detector.js";import{loadPersistedSessions as w}from"./terminal-persistence.js";const r=S("agent-process-manager");class p{constructor(){this.registry=R()}static getInstance(){return p.instance===null&&(p.instance=new p),p.instance}async startProcess(e){const{agentId:s,sessionId:t,pid:a,mode:o,workspacePath:n,command:i}=e;if(r.info(`[startProcess] Starting process: agentId=${s}, pid=${a}, mode=${o}`),await this.registry.register({agentId:s,sessionId:t,pid:a,mode:o,state:"creating",workspacePath:n,command:i}),r.debug(`[startProcess] Verifying process is running: pid=${a}`),!l(a))throw r.error(`[startProcess] Process not running after registration: agentId=${s}, pid=${a}`),await this.registry.markTerminated(s),new Error(`Process ${a} is not running`);await this.registry.update(s,{state:"running"}),await this.registry.updateHeartbeat(s),r.info(`[startProcess] Process started successfully: agentId=${s}, pid=${a}`)}async discoverAllProcesses(){r.debug("[discoverAllProcesses] Scanning for all agent processes");const e=await y(),s=this.registry.getAll(),t=[],a=new Set(s.map(i=>i.pid)),o=new Set(s.map(i=>i.agentId)),n=new Map(s.map(i=>[i.pid,i]));for(const i of e){const d=a.has(i.pid),c=i.agentId&&o.has(i.agentId),h=n.get(i.pid),u=i.agentId||h?.agentId;if(d||c){const P=s.find(f=>f.pid===i.pid||f.agentId===i.agentId||f.agentId===u);t.push({...i,agentId:u,managementStatus:"managed",sessionId:P?.sessionId})}else u?t.push({...i,agentId:u,managementStatus:"orphan"}):t.push({...i,agentId:u,managementStatus:"unknown"})}for(const i of s)if(!t.find(c=>c.pid===i.pid)){const c=l(i.pid);t.push({pid:i.pid,command:i.command,agentId:i.agentId,managementStatus:c?"managed":"orphan",sessionId:i.sessionId})}return r.debug(`[discoverAllProcesses] Discovered ${t.length} processes: ${t.filter(i=>i.managementStatus==="managed").length} managed, ${t.filter(i=>i.managementStatus==="orphan").length} orphans, ${t.filter(i=>i.managementStatus==="unknown").length} unknown`),t}async healthCheckAll(){r.debug("[healthCheckAll] Starting health check for all processes");const e=new Map,s=this.registry.getAll(),t=s.map(async a=>{const o=await this.healthCheck(a.agentId);return e.set(a.agentId,o),o});return await Promise.all(t),r.debug(`[healthCheckAll] Completed health check for ${s.length} processes`),e}async healthCheck(e){const s=this.registry.get(e);if(!s)return r.warn(`[healthCheck] Process not found in registry: agentId=${e}`),{pid:-1,agentId:e,alive:!1,cpu:0,memoryMB:0,status:"dead",lastUpdate:new Date};const t=await v(s.pid,e),a={cpu:t.cpu,memoryMB:t.memoryMB,status:t.status};return await this.registry.updateHealth(e,a),t.alive?await this.registry.updateHeartbeat(e):s.state!=="terminated"&&s.state!=="orphaned"&&(r.warn(`[healthCheck] Process died unexpectedly: agentId=${e}, pid=${s.pid}`),await this.registry.markOrphaned(e)),t}async stopProcess(e){const s=this.registry.get(e);if(!s)return{success:!1,agentId:e,pid:-1,level:0,terminated:0,failed:0,message:`Process not found in registry: ${e}`};const{pid:t}=s;if(r.info(`[stopProcess] Stopping process: agentId=${e}, pid=${t}`),!l(t))return r.info(`[stopProcess] Process already stopped: agentId=${e}, pid=${t}`),await this.registry.markTerminated(e),{success:!0,agentId:e,pid:t,level:0,terminated:1,failed:0,message:"Process was already stopped"};if(await this.registry.update(e,{state:"stopping"}),r.debug(`[stopProcess] Level 1: Sending SIGTERM to pid=${t}`),this.sendSigterm(t)&&await m(t,3e3))return await this.registry.markTerminated(e),r.info(`[stopProcess] Process stopped at Level 1: agentId=${e}, pid=${t}`),{success:!0,agentId:e,pid:t,level:1,terminated:1,failed:0,message:"Process terminated with SIGTERM"};if(r.debug(`[stopProcess] Level 2: Force killing pid=${t}`),this.sendForceKill(t)&&await m(t,3e3))return await this.registry.markTerminated(e),r.info(`[stopProcess] Process stopped at Level 2: agentId=${e}, pid=${t}`),{success:!0,agentId:e,pid:t,level:2,terminated:1,failed:0,message:"Process terminated with force kill"};r.debug(`[stopProcess] Level 3: Terminating process tree for pid=${t}`);const n=await g(t);return await m(t,5e3)?(await this.registry.markTerminated(e),r.info(`[stopProcess] Process stopped at Level 3: agentId=${e}, pid=${t}, terminated=${n.terminated}, failed=${n.failed}`),{success:!0,agentId:e,pid:t,level:3,terminated:n.terminated,failed:n.failed,message:`Process tree terminated (${n.terminated} processes)`}):(r.error(`[stopProcess] Level 4: Process is unstoppable: agentId=${e}, pid=${t}`),(l(t)?"still running":"terminated")==="terminated"?(await this.registry.markTerminated(e),{success:!0,agentId:e,pid:t,level:4,terminated:1,failed:0,message:"Process eventually terminated after all escalation levels"}):{success:!1,agentId:e,pid:t,level:4,terminated:n.terminated,failed:n.failed+1,message:"Process could not be terminated - marked as unstoppable"})}sendSigterm(e){try{return process.kill(e,"SIGTERM"),!0}catch(s){return r.debug(`[sendSigterm] Failed to send SIGTERM to ${e}:`,s),!1}}sendForceKill(e){try{return k.platform()==="win32"?I(`taskkill /PID ${e} /F`,{encoding:"utf8",timeout:5e3,windowsHide:!0}):process.kill(e,"SIGKILL"),!0}catch(s){return r.debug(`[sendForceKill] Failed to force kill ${e}:`,s),!1}}async forceKill(e){const s=this.registry.get(e);if(!s)return{success:!1,agentId:e,pid:-1,level:0,terminated:0,failed:0,message:`Process not found in registry: ${e}`};const{pid:t}=s;r.info(`[forceKill] Force killing process: agentId=${e}, pid=${t}`),await this.registry.update(e,{state:"stopping"});const a=await g(t);return await m(t,2e3)?(await this.registry.markTerminated(e),r.info(`[forceKill] Process terminated: agentId=${e}, pid=${t}`),{success:!0,agentId:e,pid:t,level:3,terminated:a.terminated,failed:a.failed,message:`Process force killed (${a.terminated} processes terminated)`}):(r.error(`[forceKill] Process could not be force killed: agentId=${e}, pid=${t}`),{success:!1,agentId:e,pid:t,level:3,terminated:a.terminated,failed:a.failed+1,message:"Force kill failed - process may require manual intervention"})}async reclaimOrphan(e){if(r.info(`[reclaimOrphan] Attempting to reclaim orphan: agentId=${e}`),this.registry.isManaged(e)){const o=this.registry.get(e);return o?(r.info(`[reclaimOrphan] Process already managed: agentId=${e}, pid=${o.pid}`),{success:!0,pid:o.pid,action:"adopted"}):{success:!1,pid:-1,action:"failed"}}const s=await $(e);if(!s)return r.warn(`[reclaimOrphan] No orphan process found: agentId=${e}`),{success:!1,pid:-1,action:"failed"};if(!l(s.pid))return r.warn(`[reclaimOrphan] Orphan process not running: agentId=${e}, pid=${s.pid}`),{success:!1,pid:s.pid,action:"failed"};if(this.registry.isManagedByPid(s.pid)){const o=this.registry.getByPid(s.pid);if(!o)try{const i=(await w()).find(d=>d.agentId===e);return await this.registry.register({agentId:e,sessionId:i?.sessionId||`reclaimed-${Date.now()}`,pid:s.pid,mode:"sdk",state:"running",workspacePath:i?.workspacePath||s.cwd||"",command:s.command||i?.command||"",metadata:{reclaimedAt:new Date().toISOString(),wasOrphan:!0}}),{success:!0,pid:s.pid,action:"adopted"}}catch{return await g(s.pid),{success:!1,pid:s.pid,action:"terminated"}}return r.warn(`[reclaimOrphan] PID already managed by different agent: pid=${s.pid}, existingAgentId=${o.agentId}`),o.agentId===e?{success:!0,pid:s.pid,action:"adopted"}:(r.warn(`[reclaimOrphan] Terminating conflicting orphan: agentId=${e}, pid=${s.pid}`),await g(s.pid),{success:!0,pid:s.pid,action:"terminated"})}const a=(await w()).find(o=>o.agentId===e);try{return await this.registry.register({agentId:e,sessionId:a?.sessionId||`reclaimed-${Date.now()}`,pid:s.pid,mode:"sdk",state:"running",workspacePath:a?.workspacePath||s.cwd||"",command:s.command||a?.command||"",metadata:{reclaimedAt:new Date().toISOString(),wasOrphan:!0}}),r.info(`[reclaimOrphan] Successfully adopted orphan: agentId=${e}, pid=${s.pid}`),{success:!0,pid:s.pid,action:"adopted"}}catch(o){return r.error(`[reclaimOrphan] Failed to adopt orphan: agentId=${e}, pid=${s.pid}`,o),await g(s.pid),{success:!1,pid:s.pid,action:"terminated"}}}async scanAndReclaimAll(){r.info("[scanAndReclaimAll] Scanning for all orphan processes");const e=[],s=await w(),t=await y(),a=new Set(this.registry.getAll().map(n=>n.pid)),o=t.filter(n=>a.has(n.pid)?!1:!!(n.agentId&&!this.registry.isManaged(n.agentId)));r.info(`[scanAndReclaimAll] Found ${o.length} orphan processes`);for(const n of o){if(!n.agentId){r.warn(`[scanAndReclaimAll] Orphan without agentId, terminating: pid=${n.pid}`),await g(n.pid),e.push({agentId:"unknown",pid:n.pid,action:"terminated"});continue}const i=await this.reclaimOrphan(n.agentId);e.push({agentId:n.agentId,pid:i.pid,action:i.action})}for(const n of s)if(n.agentId&&!this.registry.isManaged(n.agentId)&&await $(n.agentId)){const d=await this.reclaimOrphan(n.agentId);e.find(h=>h.agentId===n.agentId)||e.push({agentId:n.agentId,pid:d.pid,action:d.action})}return r.info(`[scanAndReclaimAll] Reclamation complete: ${e.length} processes processed`),e}async markOrphaned(e){return r.info(`[markOrphaned] Marking process as orphaned: agentId=${e}`),await this.registry.markOrphaned(e)}isManaged(e){return this.registry.isManaged(e)}getAllManagedProcesses(){return this.registry.getAll()}getManagedProcessesByState(e){return this.registry.getByState(e)}async getUnmanagedProcesses(){const e=await y(),s=new Set(this.registry.getAll().map(a=>a.pid)),t=new Set(this.registry.getAll().map(a=>a.agentId));return e.filter(a=>!(s.has(a.pid)||a.agentId&&t.has(a.agentId)))}async rebuildRegistry(e){r.info(`[rebuildRegistry] Rebuilding registry from ${e.length} persisted sessions`),await this.registry.clear();for(const t of e){if(!t.pid){r.debug(`[rebuildRegistry] Skipping session without PID: agentId=${t.agentId}`);continue}const a=l(t.pid),o=a?"running":"unknown";try{await this.registry.register({agentId:t.agentId,sessionId:t.sessionId,pid:t.pid,mode:"sdk",state:o,workspacePath:t.workspacePath||"",command:t.command||"",metadata:{rebuiltAt:new Date().toISOString(),wasRunningOnStartup:a}}),r.debug(`[rebuildRegistry] Registered: agentId=${t.agentId}, pid=${t.pid}, state=${o}`)}catch(n){r.warn(`[rebuildRegistry] Failed to register: agentId=${t.agentId}`,n)}}const s=this.registry.getStats();r.info(`[rebuildRegistry] Registry rebuilt: total=${s.total}, running=${s.running}, unknown=${s.unknown}`)}getStats(){return this.registry.getStats()}async cleanupStaleRegistry(){const e=this.registry.getAll();let s=0;for(const t of e)(t.state==="terminated"||t.state==="unknown")&&!l(t.pid)&&(await this.registry.remove(t.agentId),s++,r.debug(`[cleanupStaleRegistry] Removed stale entry: agentId=${t.agentId}, pid=${t.pid}, state=${t.state}`));return s>0&&r.info(`[cleanupStaleRegistry] Cleaned up ${s} stale registry entries`),s}async removeProcess(e){return r.info(`[removeProcess] Removing process from registry: agentId=${e}`),await this.registry.remove(e)}getProcess(e){return this.registry.get(e)}getProcessByPid(e){return this.registry.getByPid(e)}}p.instance=null;function T(){return p.getInstance()}export{p as AgentProcessManager,T as getAgentProcessManager};
+