aiexecode 1.0.94 → 1.0.127

package/src/system/ai_request.js

@@ -10,6 +10,26 @@ import { UnifiedLLMClient } from "../LLMClient/index.js";
 
 const debugLog = createDebugLogger('ai_request.log', 'ai_request');
 
+/**
+ * 안전한 JSON 파싱 헬퍼 함수
+ * 파싱 실패 시 에러를 던지지 않고 기본값 반환
+ * @param {string} jsonString - 파싱할 JSON 문자열
+ * @param {*} defaultValue - 파싱 실패 시 반환할 기본값
+ * @returns {*} 파싱된 객체 또는 기본값
+ */
+function safeJsonParse(jsonString, defaultValue = null) {
+    if (typeof jsonString !== 'string') {
+        return defaultValue;
+    }
+    try {
+        return JSON.parse(jsonString);
+    } catch (error) {
+        debugLog(`[safeJsonParse] JSON parsing failed: ${error.message}`);
+        debugLog(`[safeJsonParse] Input (first 200 chars): ${jsonString.substring(0, 200)}`);
+        return defaultValue;
+    }
+}
+
 // OpenAI SDK를 사용하기 위한 환경변수를 불러옵니다.
 dotenv.config({ quiet: true });
 
@@ -55,15 +75,24 @@ async function getLLMClient() {
     const currentModel = process.env.MODEL || settings?.MODEL || DEFAULT_MODEL;
     const modelInfo = getModelInfo(currentModel);
     const provider = modelInfo?.provider || 'openai';
+    const baseUrl = process.env.BASE_URL || settings?.BASE_URL || null;
 
-    debugLog('[getLLMClient] Initializing UnifiedLLMClient with API key (first 10 chars): ' + process.env.API_KEY.substring(0, 10) + '...');
-    debugLog(`[getLLMClient] Model: ${currentModel}, Provider: ${provider}`);
-    llmClient = new UnifiedLLMClient({
+    debugLog('[getLLMClient] Initializing UnifiedLLMClient with API key: [PRESENT]');
+    debugLog(`[getLLMClient] Model: ${currentModel}, Provider: ${provider}, BaseURL: ${baseUrl || '(default)'}`);
+
+    const clientConfig = {
         apiKey: process.env.API_KEY,
         model: currentModel,
         provider: provider,
         logDir: PAYLOAD_LLM_LOG_DIR
-    });
+    };
+
+    // 커스텀 BASE_URL이 설정되어 있으면 추가
+    if (baseUrl) {
+        clientConfig.baseUrl = baseUrl;
+    }
+
+    llmClient = new UnifiedLLMClient(clientConfig);
 
     debugLog('[getLLMClient] Client created successfully');
     return llmClient;
@@ -181,6 +210,7 @@ function toAbsolutePath(anyPath) {
 // 모든 AI 요청 과정에서 요청/응답 로그를 남기고 결과를 돌려줍니다.
 export async function request(taskName, requestPayload) {
     debugLog(`[request] ========== START: ${taskName} ==========`);
+
     const provider = await getCurrentProvider();
     debugLog(`[request] Provider: ${provider}`);
 
@@ -218,8 +248,8 @@ export async function request(taskName, requestPayload) {
             const msg = payloadCopy.input[i];
             const { type, call_id, output } = msg;
             if (type !== 'function_call_output') continue;
-            const parsedOutput = JSON.parse(output);
-            if (!isValidJSON(parsedOutput.stdout)) {
+            const parsedOutput = safeJsonParse(output, { stdout: output });
+            if (!parsedOutput || !isValidJSON(parsedOutput.stdout)) {
                 // stdout와 stderr를 모두 포함하는 형식으로 변환
                 const hasStdout = parsedOutput.stdout;
                 const hasStderr = parsedOutput.stderr;
@@ -235,7 +265,10 @@ export async function request(taskName, requestPayload) {
                     msg.output = parsedOutput.stdout;
                 }
             } else {
-                parsedOutput.stdout = JSON.parse(parsedOutput.stdout);
+                const parsedStdout = safeJsonParse(parsedOutput.stdout, null);
+                if (parsedStdout !== null) {
+                    parsedOutput.stdout = parsedStdout;
+                }
                 if (parsedOutput.original_result) {
                     parsedOutput.stdout = ({ ...parsedOutput.original_result, ...(parsedOutput.stdout) });
                     delete parsedOutput.original_result;
@@ -496,16 +529,24 @@ export async function request(taskName, requestPayload) {
         debugLog(`[request] Request prepared - logging to file`);
 
         // 로그는 원본 포맷으로 저장 (API 호출 전)
+        const logStartTime = Date.now();
         await logger(`${taskName}_REQ`, originalRequest, provider);
-        debugLog(`[request] Request logged - calling LLM API`);
+        debugLog(`[request] Request logged (${Date.now() - logStartTime}ms) - calling LLM API`);
 
         // AbortController의 signal을 options로 전달
         const requestOptions = {
             signal: currentAbortController.signal
         };
-        debugLog(`[request] Calling client.response with abort signal`);
+
+        // ===== API 호출 시작 =====
+        const apiCallStartTime = Date.now();
+        debugLog(`[request] >>>>> API CALL START: ${new Date(apiCallStartTime).toISOString()}`);
 
         response = await client.response(originalRequest, requestOptions);
+
+        const apiCallEndTime = Date.now();
+        const apiCallDuration = apiCallEndTime - apiCallStartTime;
+        debugLog(`[request] <<<<< API CALL END: ${apiCallDuration}ms (${new Date(apiCallEndTime).toISOString()})`);
         debugLog(`[request] Response received - id: ${response?.id}, status: ${response?.status}, output items: ${response?.output?.length || 0}`);
 
         // 원본 응답을 깊은 복사로 보존 (이후 수정으로부터 보호)
@@ -549,6 +590,84 @@ export async function request(taskName, requestPayload) {
     // 로그는 원본 포맷으로 저장
     debugLog(`[request] Logging response to file`);
     await logger(`${taskName}_RES`, originalResponse, provider);
+
+    // 화면에 응답 결과 표시 (raw JSON)
+    // 캐시 토큰 정보 추출
+    const cacheTokens = response.usage?.cache_read_input_tokens || response.usage?.input_tokens_details?.cached_tokens || 0;
+    const inputTokens = response.usage?.input_tokens || 0;
+    const cacheRatio = inputTokens > 0 ? Math.round(cacheTokens / inputTokens * 100) : 0;
+
+    const rawOutput = {
+        status: response.status,
+        output: (response.output || []).map(o => {
+            if (o.type === 'reasoning') {
+                // thinking/reasoning 블록 표시
+                const thinking = o.content?.[0]?.thinking || '';
+                return {
+                    type: 'thinking',
+                    content: thinking.length > 150 ? thinking.substring(0, 150) + `... (${thinking.length} chars)` : thinking
+                };
+            } else if (o.type === 'function_call') {
+                return {
+                    type: o.type,
+                    name: o.name,
+                    arguments: (() => {
+                        try {
+                            const args = JSON.parse(o.arguments || '{}');
+                            // 긴 인자값은 축약
+                            const truncated = {};
+                            for (const [k, v] of Object.entries(args)) {
+                                if (typeof v === 'string' && v.length > 100) {
+                                    truncated[k] = v.substring(0, 100) + `... (${v.length} chars)`;
+                                } else {
+                                    truncated[k] = v;
+                                }
+                            }
+                            return truncated;
+                        } catch {
+                            return o.arguments;
+                        }
+                    })()
+                };
+            } else if (o.type === 'message') {
+                const text = response.output_text || '';
+                return {
+                    type: o.type,
+                    text: text.length > 200 ? text.substring(0, 200) + `... (${text.length} chars)` : text
+                };
+            }
+            return { type: o.type };
+        }),
+        // 토큰 사용량 정보 추가
+        tokens: {
+            input: inputTokens,
+            output: response.usage?.output_tokens || 0,
+            cached: cacheTokens > 0 ? `${cacheTokens} (${cacheRatio}%)` : 0
+        },
+        output_text: (() => {
+            const text = response.output_text || '';
+            if (taskName === 'completion_judge') {
+                // GLM 모델 대응: 텍스트 끝에 붙은 JSON 추출
+                try {
+                    return JSON.parse(text);
+                } catch {
+                    // 텍스트에서 JSON 추출 시도
+                    const jsonMatch = text.match(/\{[^{}]*"should_complete"\s*:\s*(true|false)[^{}]*\}/);
+                    if (jsonMatch) {
+                        try {
+                            return JSON.parse(jsonMatch[0]);
+                        } catch {
+                            return text.length > 200 ? text.substring(0, 200) + `... (${text.length} chars)` : text;
+                        }
+                    }
+                    return text.length > 200 ? text.substring(0, 200) + `... (${text.length} chars)` : text;
+                }
+            }
+            return text.length > 200 ? text.substring(0, 200) + `... (${text.length} chars)` : text;
+        })()
+    };
+
+
     debugLog(`[request] ========== END: ${taskName} ==========`);
 
     return response;
@@ -566,21 +685,46 @@ export async function request(taskName, requestPayload) {
  *
  * @see https://platform.openai.com/docs/guides/error-codes
  */
+/*
+ * Z.AI/GLM 컨텍스트 초과 에러 샘플:
+ * {
+ *   "error": {
+ *     "code": "1210",
+ *     "message": "Invalid API parameter, please check the documentation.Request 320006 input tokens exceeds the model's maximum context length 202750"
+ *   },
+ *   "request_id": "20260124000100026f0914d2e744f5"
+ * }
+ * HTTP_STATUS: 400
+ */
 export function shouldRetryWithTrim(error) {
     if (!error) return false;
 
-    // OpenAI SDK의 공식 에러 코드 확인
+    // 에러 코드 및 메시지 추출
     const errorCode = error?.code || error?.error?.code;
+    const errorMessage = error?.message || error?.error?.message || '';
 
+    // OpenAI: context_length_exceeded
     if (errorCode === 'context_length_exceeded') {
-        debugLog('[shouldRetryWithTrim] Detected: context_length_exceeded');
+        debugLog('[shouldRetryWithTrim] Detected: context_length_exceeded (OpenAI)');
+        return true;
+    }
+
+    // Z.AI/GLM: code "1210" (context length exceeded)
+    if (errorCode === '1210' || errorCode === 1210) {
+        debugLog('[shouldRetryWithTrim] Detected: code 1210 (GLM context exceeded)');
+        return true;
+    }
+
+    // 메시지에서 컨텍스트 초과 패턴 감지 (다양한 API 대응)
+    const contextExceededPattern = /exceeds.*(?:context|token).*(?:length|limit|maximum)/i;
+    if (contextExceededPattern.test(errorMessage)) {
+        debugLog(`[shouldRetryWithTrim] Detected context exceeded in message: ${errorMessage.substring(0, 100)}`);
         return true;
     }
 
     // 400 에러도 trim 후 재시도 대상
     if (error?.status === 400 || error?.response?.status === 400) {
         const errorType = error?.type || error?.error?.type;
-        const errorMessage = error?.message || error?.error?.message || '';
         debugLog(
             `[shouldRetryWithTrim] Detected 400 error - ` +
             `Type: ${errorType}, Code: ${errorCode}, ` +

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 };