aiexecode 1.0.157

package/src/system/background_process.js

@@ -0,0 +1,317 @@
+/**
+ * 백그라운드 프로세스 관리 모듈
+ *
+ * AI Agent가 백그라운드로 명령어를 실행하고 관리할 수 있도록 지원
+ */
+
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+import { createDebugLogger } from '../util/debug_log.js';
+import { whichCommand } from './code_executer.js';
+
+const debugLog = createDebugLogger('background_process.log', 'background_process');
+
+/**
+ * 백그라운드 프로세스 정보
+ * @typedef {Object} BackgroundProcess
+ * @property {string} id - 고유 ID
+ * @property {string} command - 실행된 명령어
+ * @property {number} pid - 프로세스 ID
+ * @property {string} status - 상태 (running, completed, failed, killed)
+ * @property {Date} startedAt - 시작 시간
+ * @property {Date|null} endedAt - 종료 시간
+ * @property {string} stdout - 표준 출력
+ * @property {string} stderr - 표준 에러
+ * @property {number|null} exitCode - 종료 코드
+ */
+
+class BackgroundProcessManager extends EventEmitter {
+    constructor() {
+        super();
+        /** @type {Map<string, BackgroundProcess>} */
+        this.processes = new Map();
+        this.nextId = 1;
+    }
+
+    /**
+     * 고유 ID 생성
+     */
+    _generateId() {
+        return `bg_${this.nextId++}`;
+    }
+
+    /**
+     * 백그라운드로 명령어 실행
+     * @param {string} script - 실행할 스크립트
+     * @param {Object} options - 옵션
+     * @returns {Promise<{id: string, pid: number}>}
+     */
+    async run(script, options = {}) {
+        const shellPath = await whichCommand("bash") || await whichCommand("sh");
+        if (!shellPath) {
+            throw new Error('No shell found');
+        }
+
+        const id = this._generateId();
+        const startedAt = new Date();
+
+        debugLog(`[BackgroundProcess] Starting: id=${id}, script="${script.substring(0, 50)}..."`);
+
+        const child = spawn(shellPath, ['-c', script], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                DEBIAN_FRONTEND: 'noninteractive',
+                CI: 'true',
+                BATCH: '1',
+            },
+            cwd: options.cwd || process.cwd(),
+            detached: true,
+        });
+
+        const processInfo = {
+            id,
+            command: script,
+            pid: child.pid,
+            status: 'running',
+            startedAt,
+            endedAt: null,
+            stdout: '',
+            stderr: '',
+            exitCode: null,
+            _process: child, // 내부용
+        };
+
+        this.processes.set(id, processInfo);
+
+        // stdout 수집
+        child.stdout.on('data', (data) => {
+            processInfo.stdout += data.toString();
+            this.emit('output', { id, type: 'stdout', data: data.toString() });
+        });
+
+        // stderr 수집
+        child.stderr.on('data', (data) => {
+            processInfo.stderr += data.toString();
+            this.emit('output', { id, type: 'stderr', data: data.toString() });
+        });
+
+        // 프로세스 종료 처리
+        child.on('close', (code) => {
+            processInfo.status = code === 0 ? 'completed' : 'failed';
+            processInfo.exitCode = code;
+            processInfo.endedAt = new Date();
+            delete processInfo._process;
+
+            debugLog(`[BackgroundProcess] Closed: id=${id}, code=${code}`);
+            this.emit('close', { id, code, status: processInfo.status });
+        });
+
+        child.on('error', (err) => {
+            processInfo.status = 'failed';
+            processInfo.stderr += `\nError: ${err.message}`;
+            processInfo.endedAt = new Date();
+            delete processInfo._process;
+
+            debugLog(`[BackgroundProcess] Error: id=${id}, error=${err.message}`);
+            this.emit('error', { id, error: err });
+        });
+
+        this.emit('started', { id, pid: child.pid, command: script });
+
+        return { id, pid: child.pid };
+    }
+
+    /**
+     * 프로세스 종료
+     * @param {string} id - 프로세스 ID
+     * @param {string} signal - 시그널 (기본: SIGTERM)
+     * @returns {boolean} 성공 여부
+     */
+    kill(id, signal = 'SIGTERM') {
+        const processInfo = this.processes.get(id);
+        if (!processInfo) {
+            debugLog(`[BackgroundProcess] Kill failed: id=${id} not found`);
+            return false;
+        }
+
+        if (processInfo.status !== 'running') {
+            debugLog(`[BackgroundProcess] Kill skipped: id=${id} already ${processInfo.status}`);
+            return false;
+        }
+
+        const child = processInfo._process;
+        if (!child) {
+            return false;
+        }
+
+        try {
+            // 프로세스 그룹 전체 종료
+            process.kill(-child.pid, signal);
+            processInfo.status = 'killed';
+            processInfo.endedAt = new Date();
+            debugLog(`[BackgroundProcess] Killed: id=${id}, signal=${signal}`);
+            this.emit('killed', { id, signal });
+            return true;
+        } catch (err) {
+            try {
+                child.kill(signal);
+                processInfo.status = 'killed';
+                processInfo.endedAt = new Date();
+                debugLog(`[BackgroundProcess] Killed (fallback): id=${id}`);
+                this.emit('killed', { id, signal });
+                return true;
+            } catch (err2) {
+                debugLog(`[BackgroundProcess] Kill error: id=${id}, error=${err2.message}`);
+                return false;
+            }
+        }
+    }
+
+    /**
+     * 프로세스 정보 조회
+     * @param {string} id - 프로세스 ID
+     * @returns {BackgroundProcess|null}
+     */
+    get(id) {
+        const info = this.processes.get(id);
+        if (!info) return null;
+
+        // _process 필드 제외하고 반환
+        const { _process, ...publicInfo } = info;
+        return publicInfo;
+    }
+
+    /**
+     * 모든 프로세스 목록 조회
+     * @param {Object} filter - 필터 옵션
+     * @returns {BackgroundProcess[]}
+     */
+    list(filter = {}) {
+        let result = [];
+
+        for (const [id, info] of this.processes) {
+            const { _process, ...publicInfo } = info;
+
+            // 필터 적용
+            if (filter.status && publicInfo.status !== filter.status) continue;
+            if (filter.running && publicInfo.status !== 'running') continue;
+
+            result.push(publicInfo);
+        }
+
+        // 시작 시간순 정렬
+        result.sort((a, b) => b.startedAt - a.startedAt);
+
+        return result;
+    }
+
+    /**
+     * 실행 중인 프로세스 수
+     */
+    get runningCount() {
+        let count = 0;
+        for (const info of this.processes.values()) {
+            if (info.status === 'running') count++;
+        }
+        return count;
+    }
+
+    /**
+     * 완료된 프로세스 정리
+     * @param {number} maxAge - 최대 보관 시간 (ms)
+     */
+    cleanup(maxAge = 3600000) {
+        const now = Date.now();
+        const toDelete = [];
+
+        for (const [id, info] of this.processes) {
+            if (info.status !== 'running' && info.endedAt) {
+                if (now - info.endedAt.getTime() > maxAge) {
+                    toDelete.push(id);
+                }
+            }
+        }
+
+        for (const id of toDelete) {
+            this.processes.delete(id);
+            debugLog(`[BackgroundProcess] Cleaned up: id=${id}`);
+        }
+
+        return toDelete.length;
+    }
+
+    /**
+     * 모든 실행 중인 프로세스 종료
+     */
+    async killAll() {
+        const killed = [];
+        for (const [id, info] of this.processes) {
+            if (info.status === 'running') {
+                if (this.kill(id)) {
+                    killed.push(id);
+                }
+            }
+        }
+        return killed;
+    }
+}
+
+// 싱글톤 인스턴스
+let instance = null;
+
+/**
+ * BackgroundProcessManager 싱글톤 인스턴스 가져오기
+ */
+export function getBackgroundProcessManager() {
+    if (!instance) {
+        instance = new BackgroundProcessManager();
+    }
+    return instance;
+}
+
+/**
+ * 백그라운드로 명령어 실행
+ * @param {string} script - 실행할 스크립트
+ * @param {Object} options - 옵션
+ * @returns {Promise<{id: string, pid: number}>}
+ */
+export async function runInBackground(script, options = {}) {
+    const manager = getBackgroundProcessManager();
+    return await manager.run(script, options);
+}
+
+/**
+ * 백그라운드 프로세스 종료
+ * @param {string} id - 프로세스 ID
+ */
+export function killBackgroundProcess(id) {
+    const manager = getBackgroundProcessManager();
+    return manager.kill(id);
+}
+
+/**
+ * 백그라운드 프로세스 목록 조회
+ */
+export function listBackgroundProcesses(filter = {}) {
+    const manager = getBackgroundProcessManager();
+    return manager.list(filter);
+}
+
+/**
+ * 백그라운드 프로세스 정보 조회
+ */
+export function getBackgroundProcess(id) {
+    const manager = getBackgroundProcessManager();
+    return manager.get(id);
+}
+
+/**
+ * 모든 백그라운드 프로세스 종료 (앱 종료 시)
+ */
+export async function killAllBackgroundProcesses() {
+    const manager = getBackgroundProcessManager();
+    return await manager.killAll();
+}
+
+export { BackgroundProcessManager };