aws-runtime-bridge 1.0.0

package/dist/services/orphan-monitor.d.ts

@@ -0,0 +1,94 @@
+/**
+ * 孤儿进程监控服务
+ *
+ * 定期扫描和检测孤儿进程，支持自动清理和告警
+ */
+/**
+ * 孤儿进程事件类型
+ */
+export type OrphanEventType = 'orphan_detected' | 'orphan_cleaned' | 'process_unresponsive' | 'process_high_cpu' | 'process_high_memory' | 'health_check';
+/**
+ * 孤儿进程事件
+ */
+export interface OrphanEvent {
+    type: OrphanEventType;
+    agentId: string;
+    pid?: number;
+    message: string;
+    timestamp: Date;
+    details?: Record<string, unknown>;
+}
+/**
+ * 孤儿进程监控器
+ */
+export declare class OrphanMonitor {
+    private intervalId;
+    private lastScanTime;
+    private eventListeners;
+    private stopped;
+    /**
+     * 启动监控器
+     */
+    start(): Promise<void>;
+    /**
+     * 停止监控器
+     */
+    stop(): void;
+    /**
+     * 执行一次扫描
+     */
+    scan(): Promise<void>;
+    /**
+     * 处理检测到的孤儿进程
+     */
+    private handleOrphanDetected;
+    /**
+     * 处理健康异常
+     */
+    private handleHealthIssue;
+    /**
+     * 自动清理孤儿进程
+     */
+    private autoCleanOrphan;
+    /**
+     * 清理已死亡的会话记录
+     */
+    private cleanupDeadSessions;
+    /**
+     * 上报事件到调度中心
+     */
+    private reportToScheduler;
+    /**
+     * 注册事件监听器
+     */
+    onEvent(listener: (event: OrphanEvent) => void): void;
+    /**
+     * 移除事件监听器
+     */
+    offEvent(listener: (event: OrphanEvent) => void): void;
+    /**
+     * 触发事件
+     */
+    private emit;
+    /**
+     * 获取监控状态
+     */
+    getStatus(): {
+        running: boolean;
+        lastScanTime: Date | null;
+        mode: string;
+    };
+}
+/**
+ * 获取孤儿进程监控器实例
+ */
+export declare function getOrphanMonitor(): OrphanMonitor;
+/**
+ * 启动孤儿进程监控
+ */
+export declare function startOrphanMonitor(): Promise<void>;
+/**
+ * 停止孤儿进程监控
+ */
+export declare function stopOrphanMonitor(): void;
+//# sourceMappingURL=orphan-monitor.d.ts.map

package/dist/services/orphan-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orphan-monitor.d.ts","sourceRoot":"","sources":["../../src/services/orphan-monitor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAyBH;;GAEG;AACH,MAAM,MAAM,eAAe,GACvB,iBAAiB,GACjB,gBAAgB,GAChB,sBAAsB,GACtB,kBAAkB,GAClB,qBAAqB,GACrB,cAAc,CAAC;AAEnB;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,cAAc,CAA2C;IACjE,OAAO,CAAC,OAAO,CAAkB;IAEjC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB5B;;OAEG;IACH,IAAI,IAAI,IAAI;IASZ;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA0E3B;;OAEG;YACW,oBAAoB;IA8BlC;;OAEG;YACW,iBAAiB;IAgC/B;;OAEG;YACW,eAAe;IA0B7B;;OAEG;YACW,mBAAmB;IAsBjC;;OAEG;YACW,iBAAiB;IAwC/B;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,IAAI;IAIrD;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,IAAI;IAOtD;;OAEG;IACH,OAAO,CAAC,IAAI;IAUZ;;OAEG;IACH,SAAS,IAAI;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,YAAY,EAAE,IAAI,GAAG,IAAI,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAO3E;AAKD;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,CAKhD;AAED;;GAEG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAGxD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAGxC"}

package/dist/services/orphan-monitor.js

@@ -0,0 +1,321 @@
+/**
+ * 孤儿进程监控服务
+ *
+ * 定期扫描和检测孤儿进程，支持自动清理和告警
+ */
+import { createLogger } from '../utils/logger.js';
+import { loadPersistedSessions, savePersistedSessions } from './terminal-persistence.js';
+import { detectOrphanProcesses, checkAllSessionsHealth, terminateProcessTree, waitForProcessExit } from './process-detector.js';
+import { ORPHAN_SCAN_INTERVAL, ORPHAN_AUTO_CLEAN_MODE, ORPHAN_SCAN_ENABLED, schedulerBaseUrl, runtimeToken } from '../config.js';
+const logger = createLogger('orphan-monitor');
+/**
+ * 孤儿进程监控器
+ */
+export class OrphanMonitor {
+    constructor() {
+        this.intervalId = null;
+        this.lastScanTime = null;
+        this.eventListeners = [];
+        this.stopped = false; // ★ 停止标志位，用于中断正在执行的 scan()
+    }
+    /**
+     * 启动监控器
+     */
+    async start() {
+        if (!ORPHAN_SCAN_ENABLED) {
+            logger.info('孤儿进程监控已禁用 (AWS_ORPHAN_SCAN_ENABLED=false)');
+            return;
+        }
+        this.stopped = false; // ★ 重置停止标志
+        logger.info(`启动孤儿进程监控，扫描间隔: ${ORPHAN_SCAN_INTERVAL}ms, 自动清理模式: ${ORPHAN_AUTO_CLEAN_MODE}`);
+        // 立即执行一次检测
+        await this.scan();
+        // 设置定期扫描
+        this.intervalId = setInterval(async () => {
+            await this.scan();
+        }, ORPHAN_SCAN_INTERVAL);
+        logger.info('孤儿进程监控已启动');
+    }
+    /**
+     * 停止监控器
+     */
+    stop() {
+        this.stopped = true; // ★ 设置停止标志，中断正在执行的 scan()
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+            logger.info('孤儿进程监控已停止');
+        }
+    }
+    /**
+     * 执行一次扫描
+     */
+    async scan() {
+        // ★ 如果已停止，立即退出
+        if (this.stopped) {
+            logger.debug('监控器已停止，跳过扫描');
+            return;
+        }
+        this.lastScanTime = new Date();
+        logger.debug('开始扫描孤儿进程...');
+        try {
+            // 加载持久化会话
+            const persistedSessions = await loadPersistedSessions();
+            // ★ 检查停止标志（异步操作后）
+            if (this.stopped) {
+                logger.debug('监控器已停止，中断扫描');
+                return;
+            }
+            if (persistedSessions.length === 0) {
+                logger.debug('无持久化会话，跳过扫描');
+                return;
+            }
+            // 检测孤儿进程
+            const orphans = detectOrphanProcesses(persistedSessions.map(s => ({
+                agentId: s.agentId,
+                pid: s.pid,
+                workspacePath: s.workspacePath,
+                command: s.command,
+            })));
+            // ★ 检查停止标志（异步操作后）
+            if (this.stopped) {
+                logger.debug('监控器已停止，中断扫描');
+                return;
+            }
+            // 检测进程健康状态
+            const healthStatuses = await checkAllSessionsHealth(persistedSessions.filter(s => s.pid).map(s => ({ agentId: s.agentId, pid: s.pid })));
+            // ★ 检查停止标志（异步操作后）
+            if (this.stopped) {
+                logger.debug('监控器已停止，中断扫描');
+                return;
+            }
+            // 处理孤儿进程
+            for (const orphan of orphans) {
+                if (this.stopped)
+                    break; // ★ 循环中检查停止标志
+                await this.handleOrphanDetected(orphan.agentId, orphan.process.pid);
+            }
+            // 处理健康异常进程
+            for (const [agentId, health] of healthStatuses) {
+                if (this.stopped)
+                    break; // ★ 循环中检查停止标志
+                if (health.status !== 'healthy' && health.alive) {
+                    await this.handleHealthIssue(agentId, health);
+                }
+            }
+            // 清理不存在的会话（PID 死了但记录还在）
+            if (!this.stopped) {
+                await this.cleanupDeadSessions(persistedSessions, healthStatuses);
+            }
+        }
+        catch (error) {
+            logger.warn('扫描孤儿进程失败:', error);
+        }
+    }
+    /**
+     * 处理检测到的孤儿进程
+     */
+    async handleOrphanDetected(agentId, pid) {
+        const event = {
+            type: 'orphan_detected',
+            agentId,
+            pid,
+            message: `检测到孤儿进程: agentId=${agentId}, pid=${pid}`,
+            timestamp: new Date(),
+        };
+        this.emit(event);
+        logger.warn(`检测到孤儿进程: agentId=${agentId}, pid=${pid}`);
+        // 根据模式处理
+        switch (ORPHAN_AUTO_CLEAN_MODE) {
+            case 'auto':
+                // 自动终止
+                await this.autoCleanOrphan(agentId, pid);
+                break;
+            case 'alert':
+                // 告警并等待处理
+                await this.reportToScheduler(agentId, 'orphan_detected', { pid });
+                break;
+            case 'manual':
+                // 仅记录日志，等待手动处理
+                logger.info('manual 模式，仅记录日志，不自动处理');
+                break;
+        }
+    }
+    /**
+     * 处理健康异常
+     */
+    async handleHealthIssue(agentId, health) {
+        const eventType = health.status === 'unresponsive' ? 'process_unresponsive'
+            : health.status === 'high_cpu' ? 'process_high_cpu'
+                : 'process_high_memory';
+        const event = {
+            type: eventType,
+            agentId,
+            pid: health.pid,
+            message: `进程健康异常: ${health.status}, CPU=${health.cpu}%, Memory=${health.memoryMB}MB`,
+            timestamp: new Date(),
+            details: {
+                cpu: health.cpu,
+                memoryMB: health.memoryMB,
+            },
+        };
+        this.emit(event);
+        // 告警到调度中心
+        await this.reportToScheduler(agentId, eventType, {
+            pid: health.pid,
+            cpu: health.cpu,
+            memoryMB: health.memoryMB,
+        });
+        // auto 模式下可以考虑终止异常进程
+        if (ORPHAN_AUTO_CLEAN_MODE === 'auto' && health.status !== 'healthy') {
+            logger.warn(`auto 模式: 终止异常进程 ${health.pid} (${health.status})`);
+            await this.autoCleanOrphan(agentId, health.pid);
+        }
+    }
+    /**
+     * 自动清理孤儿进程
+     */
+    async autoCleanOrphan(agentId, pid) {
+        logger.info(`自动清理孤儿进程：agentId=${agentId}, pid=${pid}`);
+        // 使用进程树终止
+        const result = terminateProcessTree(pid);
+        // 等待进程完全终止（最多 5 秒）
+        const exited = waitForProcessExit(pid, 5000);
+        if (result.terminated > 0 && exited) {
+            const event = {
+                type: 'orphan_cleaned',
+                agentId,
+                pid,
+                message: `自动清理成功：agentId=${agentId}, pid=${pid}, 终止了 ${result.terminated} 个进程`,
+                timestamp: new Date(),
+                details: { terminated: result.terminated, failed: result.failed },
+            };
+            this.emit(event);
+            await this.reportToScheduler(agentId, 'orphan_cleaned', { pid, terminated: result.terminated, failed: result.failed });
+        }
+        else {
+            logger.warn(`自动清理失败：agentId=${agentId}, pid=${pid}, terminated=${result.terminated}, exited=${exited}`);
+            await this.reportToScheduler(agentId, 'orphan_clean_failed', { pid, terminated: result.terminated, failed: result.failed });
+        }
+    }
+    /**
+     * 清理已死亡的会话记录
+     */
+    async cleanupDeadSessions(sessions, healthStatuses) {
+        const deadSessions = sessions.filter(s => {
+            if (!s.pid)
+                return false;
+            const health = healthStatuses.get(s.agentId);
+            return !health?.alive;
+        });
+        if (deadSessions.length > 0) {
+            logger.info(`清理 ${deadSessions.length} 个已死亡会话记录`);
+            const aliveSessions = sessions.filter(s => {
+                const health = healthStatuses.get(s.agentId);
+                return health?.alive !== false;
+            });
+            await savePersistedSessions(aliveSessions);
+        }
+    }
+    /**
+     * 上报事件到调度中心
+     */
+    async reportToScheduler(agentId, eventType, details) {
+        // ★ 如果已停止，跳过上报（关闭时调度中心可能已不可达）
+        if (this.stopped) {
+            logger.debug(`监控器已停止，跳过上报: ${eventType}`);
+            return;
+        }
+        try {
+            const response = await fetch(`${schedulerBaseUrl}/api/runtime/orphan-event`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${runtimeToken}`,
+                },
+                body: JSON.stringify({
+                    agentId,
+                    eventType,
+                    details,
+                    timestamp: new Date().toISOString(),
+                }),
+            });
+            if (!response.ok) {
+                // ★ 404 表示调度中心不可达或已关闭，降低日志级别避免噪音
+                if (response.status === 404) {
+                    logger.debug(`上报失败: 调度中心不可达 (404)，事件: ${eventType}`);
+                }
+                else {
+                    logger.warn(`上报失败: ${response.status}`);
+                }
+            }
+        }
+        catch (error) {
+            // ★ 网络错误时降低日志级别（关闭时常见）
+            logger.debug('上报到调度中心失败:', error);
+        }
+    }
+    /**
+     * 注册事件监听器
+     */
+    onEvent(listener) {
+        this.eventListeners.push(listener);
+    }
+    /**
+     * 移除事件监听器
+     */
+    offEvent(listener) {
+        const index = this.eventListeners.indexOf(listener);
+        if (index > -1) {
+            this.eventListeners.splice(index, 1);
+        }
+    }
+    /**
+     * 触发事件
+     */
+    emit(event) {
+        for (const listener of this.eventListeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                logger.warn('事件监听器执行失败:', error);
+            }
+        }
+    }
+    /**
+     * 获取监控状态
+     */
+    getStatus() {
+        return {
+            running: this.intervalId !== null,
+            lastScanTime: this.lastScanTime,
+            mode: ORPHAN_AUTO_CLEAN_MODE,
+        };
+    }
+}
+// 单例实例
+let orphanMonitorInstance = null;
+/**
+ * 获取孤儿进程监控器实例
+ */
+export function getOrphanMonitor() {
+    if (!orphanMonitorInstance) {
+        orphanMonitorInstance = new OrphanMonitor();
+    }
+    return orphanMonitorInstance;
+}
+/**
+ * 启动孤儿进程监控
+ */
+export async function startOrphanMonitor() {
+    const monitor = getOrphanMonitor();
+    await monitor.start();
+}
+/**
+ * 停止孤儿进程监控
+ */
+export function stopOrphanMonitor() {
+    const monitor = getOrphanMonitor();
+    monitor.stop();
+}

package/dist/services/process-detector.d.ts

@@ -0,0 +1,175 @@
+/**
+ * 进程检测服务
+ *
+ * 用于检测孤儿进程（当 runtime-bridge 异常关闭后仍在运行的 Agent 进程）
+ */
+/**
+ * 检测进程是否存活
+ *
+ * @param pid 进程 ID
+ * @returns 是否存活
+ */
+export declare function isProcessRunning(pid: number): boolean;
+/**
+ * 进程信息
+ */
+export interface ProcessInfo {
+    pid: number;
+    command: string;
+    cwd?: string;
+    agentId?: string;
+    startedAt?: string;
+}
+/**
+ * 查找 Agent 相关的进程（Claude Code、OpenCode 等）
+ *
+ * @returns 匹配的进程列表
+ */
+export declare function findClaudeCodeProcesses(): ProcessInfo[];
+/**
+ * 根据 agentId 查找孤儿进程
+ *
+ * 检测策略（按优先级）：
+ * 1. 通过命令行中的 agentId 直接匹配
+ * 2. Windows: 通过 PowerShell 在命令行中模糊搜索 agentId
+ * 3. Windows: 通过进程树搜索（解决 PTY 场景下 agentId 仅存在于环境变量的问题）
+ *    PTY 启动链: pty.spawn('powershell.exe', {env: {AWS_AGENT_ID}}) → 用户运行 'claude'
+ *    此时 claude 是 powershell 子进程，agentId 仅存在于父进程的环境变量中
+ *
+ * @param agentId Agent ID
+ * @returns 进程信息或 undefined
+ */
+export declare function findOrphanProcessByAgentId(agentId: string): ProcessInfo | undefined;
+/**
+ * 通过工作目录路径查找孤儿进程
+ *
+ * 当 agentId 无法匹配到进程时，通过工作目录路径做宽泛搜索。
+ * 适用于以下场景：
+ * - runtime-bridge 重启后持久化会话丢失
+ * - PTY 模式下 agentId 仅在环境变量中，命令行搜索不到
+ * - 进程树断链，无法通过祖先链匹配
+ *
+ * @param workspacePath 工作目录路径
+ * @returns 匹配的进程信息或 undefined
+ */
+export declare function findOrphanProcessByWorkspace(workspacePath: string): ProcessInfo | undefined;
+/**
+ * 根据 PID 终止进程
+ *
+ * @param pid 进程 ID
+ * @returns 是否成功
+ */
+export declare function terminateProcess(pid: number): boolean;
+/**
+ * 终止进程树（包括所有子进程）
+ *
+ * 跨平台实现：
+ * - Windows: 使用 taskkill /T 终止整个进程树
+ * - Unix: 递归获取所有子进程并逐个终止
+ *
+ * @param pid 进程 ID
+ * @returns { terminated: 成功终止的进程数，failed: 失败的进程数 }
+ */
+export declare function terminateProcessTree(pid: number): {
+    terminated: number;
+    failed: number;
+};
+/**
+ * 等待进程完全终止（轮询检测）
+ *
+ * @param pid 进程 ID
+ * @param timeoutMs 超时时间（毫秒）
+ * @returns 是否成功终止
+ */
+export declare function waitForProcessExit(pid: number, timeoutMs?: number): boolean;
+/**
+ * 检测并收集所有孤儿进程信息
+ * 用于 runtime-bridge 启动时恢复控制
+ *
+ * 改进策略：
+ * 1. 检查持久化会话中的 PID 是否仍在运行（使用可靠的 isProcessRunning）
+ * 2. PID 存活时，优先从进程列表匹配详细信息，匹配不到则用持久化信息构造
+ * 3. 对于没有 PID 的会话，通过 agentId 搜索进程（包括环境变量搜索）
+ *
+ * @param persistedSessions 持久化的会话列表（包含 PID 信息）
+ * @returns 孤儿进程列表
+ */
+export declare function detectOrphanProcesses(persistedSessions: Array<{
+    agentId: string;
+    pid?: number;
+    workspacePath?: string;
+    command?: string;
+}>): Array<{
+    agentId: string;
+    process: ProcessInfo;
+    sessionInfo: {
+        workspacePath?: string;
+        command?: string;
+    };
+}>;
+/**
+ * 进程健康状态
+ */
+export interface ProcessHealthStatus {
+    pid: number;
+    agentId: string;
+    alive: boolean;
+    cpu: number;
+    memoryMB: number;
+    status: 'healthy' | 'unresponsive' | 'high_cpu' | 'high_memory' | 'dead';
+    lastUpdate: Date;
+}
+/**
+ * 检测进程健康状态
+ *
+ * @param pid 进程 ID
+ * @param agentId Agent ID
+ * @returns 健康状态
+ */
+export declare function checkProcessHealth(pid: number, agentId: string): Promise<ProcessHealthStatus>;
+/**
+ * 批量检测会话健康状态
+ *
+ * @param sessions 持久化会话列表
+ * @returns 健康状态列表
+ */
+export declare function checkAllSessionsHealth(sessions: Array<{
+    agentId: string;
+    pid?: number;
+}>): Promise<Map<string, ProcessHealthStatus>>;
+/**
+ * 发现进程管理状态
+ */
+export type ProcessManagementStatus = 'managed' | 'orphan' | 'unknown';
+/**
+ * 发现的进程信息（含管理状态）
+ */
+export interface DiscoveredProcessInfo extends ProcessInfo {
+    managementStatus: ProcessManagementStatus;
+    sessionId?: string;
+    isRunning: boolean;
+    lastSeen?: string;
+}
+/**
+ * 全局发现：扫描机器上所有 Agent 进程，并标注管理状态
+ *
+ * 返回三类进程：
+ * - managed: 在注册表中且进程存活
+ * - orphan: 进程存在但不在注册表中（脱离控制）
+ * - unknown: 在注册表中但进程已死亡
+ *
+ * @param managedPids 已知被管理的 PID 集合（来自 ProcessRegistry）
+ * @returns 发现的进程列表
+ */
+export declare function discoverAllProcesses(managedPids?: Set<number>, managedAgentIds?: Set<string>): DiscoveredProcessInfo[];
+/**
+ * 批量发现：扫描所有进程并补充注册表中缺失的进程状态
+ *
+ * @param registryExport 注册表导出的进程记录（含 agentId, pid）
+ * @returns 完整的发现结果
+ */
+export declare function discoverAllProcessesFull(registryExport: Array<{
+    agentId: string;
+    pid: number;
+}>): DiscoveredProcessInfo[];
+//# sourceMappingURL=process-detector.d.ts.map

package/dist/services/process-detector.d.ts.map

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