aiexecode 1.0.126 → 1.0.127

package/src/system/code_executer.js

@@ -7,12 +7,412 @@ import { installRequiredPackages } from '../ai_based/pip_package_installer.js';
 import { write_file } from '../tools/code_editor.js';
 import { CONFIG_DIR, ensureConfigDirectory } from '../util/config.js';
 import { createDebugLogger } from '../util/debug_log.js';
+import crypto from 'crypto';
 
 const debugLog = createDebugLogger('code_executer.log', 'code_executer');
 
 // 이 파일은 파이썬과 쉘 코드를 실행하고 필요한 패키지를 설치하는 역할을 담당합니다.
 // Orchestrator가 run_python_code와 bash 도구로 생산한 스크립트를 실제 환경에서 실행할 때 이 모듈을 직접 호출합니다.
 
+/**
+ * PersistentShell - 앱 구동 동안 쉘 세션을 유지하는 클래스
+ *
+ * 기존 방식: 매번 임시 .sh 파일 생성 → spawn → 종료 (상태 소실)
+ * 새로운 방식: 하나의 bash 세션을 유지하며 stdin으로 명령 전송 (상태 유지)
+ */
+class PersistentShell {
+    constructor() {
+        this.shell = null;
+        this.isReady = false;
+        this.commandQueue = [];
+        this.currentCommand = null;
+        this.outputBuffer = '';
+        this.stderrBuffer = '';
+        this.shellPath = null;
+    }
+
+    /**
+     * 쉘 세션 시작
+     */
+    async start() {
+        if (this.shell && this.isReady) {
+            debugLog('[PersistentShell] Shell already running');
+            return true;
+        }
+
+        this.shellPath = await whichCommand("bash") || await whichCommand("sh");
+        if (!this.shellPath) {
+            debugLog('[PersistentShell] ERROR: No shell found');
+            return false;
+        }
+
+        debugLog(`[PersistentShell] Starting shell: ${this.shellPath}`);
+
+        this.shell = spawn(this.shellPath, [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                DEBIAN_FRONTEND: 'noninteractive',
+                CI: 'true',
+                BATCH: '1',
+                // PS1을 비워서 프롬프트가 출력에 섞이지 않도록
+                PS1: '',
+                PS2: '',
+            },
+            cwd: process.cwd(),
+        });
+
+        this.shell.stdout.on('data', (data) => {
+            this.outputBuffer += data.toString();
+            this._checkCommandComplete();
+        });
+
+        this.shell.stderr.on('data', (data) => {
+            this.stderrBuffer += data.toString();
+        });
+
+        this.shell.on('close', (code) => {
+            debugLog(`[PersistentShell] Shell closed with code ${code}`);
+
+            // _stopInternal에서 이미 shell을 null로 설정한 경우 중복 처리 방지
+            if (!this.shell) return;
+
+            this.isReady = false;
+            this.shell = null;
+
+            // 현재 진행 중인 명령이 있다면 에러로 처리
+            if (this.currentCommand) {
+                if (this.currentCommand.timeoutHandle) {
+                    clearTimeout(this.currentCommand.timeoutHandle);
+                }
+                this.currentCommand.reject(new Error('Shell closed unexpectedly'));
+                this.currentCommand = null;
+            }
+
+            // 큐에 있는 명령들도 에러로 처리
+            while (this.commandQueue.length > 0) {
+                const queued = this.commandQueue.shift();
+                queued.reject(new Error('Shell closed unexpectedly'));
+            }
+        });
+
+        this.shell.on('error', (err) => {
+            debugLog(`[PersistentShell] Shell error: ${err.message}`);
+
+            // _stopInternal에서 이미 shell을 null로 설정한 경우 중복 처리 방지
+            if (!this.shell) return;
+
+            this.isReady = false;
+
+            // 현재 진행 중인 명령이 있다면 에러로 처리
+            if (this.currentCommand) {
+                if (this.currentCommand.timeoutHandle) {
+                    clearTimeout(this.currentCommand.timeoutHandle);
+                }
+                this.currentCommand.reject(err);
+                this.currentCommand = null;
+            }
+
+            // 큐에 있는 명령들도 에러로 처리
+            while (this.commandQueue.length > 0) {
+                const queued = this.commandQueue.shift();
+                queued.reject(err);
+            }
+        });
+
+        this.isReady = true;
+        debugLog('[PersistentShell] Shell started successfully');
+        return true;
+    }
+
+    /**
+     * 명령어 완료 여부 확인 (마커 기반)
+     */
+    _checkCommandComplete() {
+        if (!this.currentCommand) return;
+
+        const { endMarker, exitCodeMarker } = this.currentCommand;
+
+        // 종료 마커와 exit code 마커가 모두 있는지 확인
+        const endMarkerIndex = this.outputBuffer.indexOf(endMarker);
+        if (endMarkerIndex === -1) return;
+
+        const exitCodeMatch = this.outputBuffer.match(new RegExp(`${exitCodeMarker}(\\d+)${exitCodeMarker}`));
+        if (!exitCodeMatch) return;
+
+        // 명령어 출력 추출 (시작 마커 이후, exit code 마커 이전)
+        const { startMarker } = this.currentCommand;
+        const startMarkerIndex = this.outputBuffer.indexOf(startMarker);
+        const exitCodeMarkerIndex = this.outputBuffer.indexOf(exitCodeMarker);
+
+        let stdout = '';
+        if (startMarkerIndex !== -1 && exitCodeMarkerIndex !== -1) {
+            stdout = this.outputBuffer.substring(
+                startMarkerIndex + startMarker.length + 1, // +1 for newline
+                exitCodeMarkerIndex
+            );
+        }
+
+        const exitCode = parseInt(exitCodeMatch[1], 10);
+        const stderr = this.stderrBuffer;
+
+        debugLog(`[PersistentShell] Command complete, exit code: ${exitCode}`);
+        debugLog(`[PersistentShell] stdout length: ${stdout.length}, stderr length: ${stderr.length}`);
+
+        // 타임아웃 핸들러 정리
+        if (this.currentCommand.timeoutHandle) {
+            clearTimeout(this.currentCommand.timeoutHandle);
+        }
+
+        // 버퍼 초기화
+        this.outputBuffer = '';
+        this.stderrBuffer = '';
+
+        // Promise resolve
+        const { resolve } = this.currentCommand;
+        this.currentCommand = null;
+
+        resolve({
+            stdout: stdout.trim(),
+            stderr: stderr.trim(),
+            code: exitCode,
+            timeout: false
+        });
+
+        // 다음 명령 처리
+        this._processNextCommand();
+    }
+
+    /**
+     * 큐에서 다음 명령 처리
+     */
+    _processNextCommand() {
+        if (this.currentCommand || this.commandQueue.length === 0) return;
+
+        const next = this.commandQueue.shift();
+        this._executeCommand(next.script, next.timeoutMs, next.resolve, next.reject);
+    }
+
+    /**
+     * 명령어 실행 (내부)
+     */
+    _executeCommand(script, timeoutMs, resolve, reject) {
+        // 고유한 마커 생성
+        const commandId = crypto.randomBytes(8).toString('hex');
+        const startMarker = `__AIEXE_START_${commandId}__`;
+        const endMarker = `__AIEXE_END_${commandId}__`;
+        const exitCodeMarker = `__AIEXE_EXIT_${commandId}_`;
+
+        this.currentCommand = {
+            script,
+            startMarker,
+            endMarker,
+            exitCodeMarker,
+            resolve,
+            reject,
+            startTime: Date.now()
+        };
+
+        // 타임아웃 설정
+        const timeoutHandle = setTimeout(() => {
+            if (this.currentCommand && this.currentCommand.startMarker === startMarker) {
+                debugLog(`[PersistentShell] Command timeout after ${timeoutMs}ms`);
+                const stdout = this.outputBuffer;
+                const stderr = this.stderrBuffer + '\n[TIMEOUT] Command execution terminated due to timeout';
+
+                this.outputBuffer = '';
+                this.stderrBuffer = '';
+                this.currentCommand = null;
+
+                resolve({
+                    stdout: stdout.trim(),
+                    stderr: stderr.trim(),
+                    code: 1,
+                    timeout: true
+                });
+
+                // 타임아웃 후 쉘 재시작 (상태가 불확실하므로)
+                this.restart();
+            }
+        }, timeoutMs);
+
+        this.currentCommand.timeoutHandle = timeoutHandle;
+
+        // 명령어를 마커로 감싸서 전송
+        // 형식: echo start_marker; script; exit_code=$?; echo exit_marker$exit_code_exit_marker; echo end_marker
+        const wrappedScript = `echo '${startMarker}'
+${script}
+__exit_code__=$?
+echo '${exitCodeMarker}'$__exit_code__'${exitCodeMarker}'
+echo '${endMarker}'
+`;
+
+        debugLog(`[PersistentShell] Executing command (id: ${commandId})`);
+        debugLog(`[PersistentShell] Script: ${script.substring(0, 100)}${script.length > 100 ? '...' : ''}`);
+
+        this.shell.stdin.write(wrappedScript);
+    }
+
+    /**
+     * 명령어 실행 (외부 인터페이스)
+     */
+    async exec(script, timeoutMs = 1200000) {
+        if (!this.isReady) {
+            const started = await this.start();
+            if (!started) {
+                return {
+                    stdout: '',
+                    stderr: 'Failed to start shell',
+                    code: 1,
+                    timeout: false
+                };
+            }
+        }
+
+        return new Promise((resolve, reject) => {
+            if (this.currentCommand) {
+                // 이미 실행 중인 명령이 있으면 큐에 추가
+                this.commandQueue.push({ script, timeoutMs, resolve, reject });
+            } else {
+                this._executeCommand(script, timeoutMs, resolve, reject);
+            }
+        });
+    }
+
+    /**
+     * 쉘 재시작 (큐 보존)
+     */
+    async restart() {
+        debugLog('[PersistentShell] Restarting shell...');
+
+        // 큐 보존
+        const savedQueue = [...this.commandQueue];
+        this.commandQueue = [];
+
+        await this._stopInternal(false); // 큐 에러 처리 안 함
+        const started = await this.start();
+
+        // 큐 복원 및 처리 재개
+        if (started && savedQueue.length > 0) {
+            debugLog(`[PersistentShell] Restoring ${savedQueue.length} queued commands`);
+            this.commandQueue = savedQueue;
+            this._processNextCommand();
+        }
+
+        return started;
+    }
+
+    /**
+     * 쉘 종료 (외부 인터페이스)
+     */
+    async stop() {
+        await this._stopInternal(true);
+    }
+
+    /**
+     * 쉘 종료 (내부)
+     * @param {boolean} rejectQueue - 큐에 있는 명령들을 에러로 처리할지 여부
+     */
+    async _stopInternal(rejectQueue = true) {
+        if (this.shell) {
+            debugLog('[PersistentShell] Stopping shell...');
+
+            // 현재 명령의 타임아웃 핸들러 정리
+            if (this.currentCommand && this.currentCommand.timeoutHandle) {
+                clearTimeout(this.currentCommand.timeoutHandle);
+            }
+
+            // close 이벤트에서 큐가 처리되지 않도록 플래그 설정
+            const shellToKill = this.shell;
+            this.shell = null;
+            this.isReady = false;
+
+            try {
+                shellToKill.stdin.end();
+                shellToKill.kill('SIGTERM');
+
+                // 잠시 대기 후 강제 종료
+                await new Promise(resolve => setTimeout(resolve, 100));
+                if (!shellToKill.killed) {
+                    shellToKill.kill('SIGKILL');
+                }
+            } catch (err) {
+                debugLog(`[PersistentShell] Error stopping shell: ${err.message}`);
+            }
+
+            // 큐 처리
+            if (rejectQueue) {
+                while (this.commandQueue.length > 0) {
+                    const queued = this.commandQueue.shift();
+                    queued.reject(new Error('Shell stopped'));
+                }
+            }
+
+            this.currentCommand = null;
+            this.outputBuffer = '';
+            this.stderrBuffer = '';
+        }
+    }
+
+    /**
+     * 현재 작업 디렉토리 확인
+     */
+    async getCwd() {
+        const result = await this.exec('pwd', 5000);
+        return result.code === 0 ? result.stdout.trim() : null;
+    }
+
+    /**
+     * 작업 디렉토리를 지정된 경로로 리셋
+     * @param {string} targetDir - 이동할 디렉토리 (기본: process.cwd())
+     */
+    async resetCwd(targetDir = null) {
+        const dir = targetDir || process.cwd();
+        debugLog(`[PersistentShell] Resetting cwd to: ${dir}`);
+        const result = await this.exec(`cd "${dir}"`, 5000);
+        if (result.code !== 0) {
+            debugLog(`[PersistentShell] Failed to reset cwd: ${result.stderr}`);
+        }
+        return result.code === 0;
+    }
+}
+
+// 싱글톤 인스턴스
+let persistentShellInstance = null;
+
+/**
+ * PersistentShell 싱글톤 인스턴스 가져오기
+ */
+export function getPersistentShell() {
+    if (!persistentShellInstance) {
+        persistentShellInstance = new PersistentShell();
+    }
+    return persistentShellInstance;
+}
+
+/**
+ * PersistentShell 종료 (앱 종료 시 호출)
+ */
+export async function closePersistentShell() {
+    if (persistentShellInstance) {
+        await persistentShellInstance.stop();
+        persistentShellInstance = null;
+    }
+}
+
+/**
+ * 쉘의 작업 디렉토리를 리셋 (새 세션 시작 시 호출)
+ * @param {string} targetDir - 이동할 디렉토리 (기본: process.cwd())
+ */
+export async function resetShellCwd(targetDir = null) {
+    const shell = getPersistentShell();
+    if (shell.isReady) {
+        return await shell.resetCwd(targetDir);
+    }
+    // 쉘이 아직 시작되지 않았으면 start()에서 cwd가 설정되므로 OK
+    return true;
+}
+
 dotenv.config({ quiet: true });
 
 // 사용 가능한 파이썬 실행 파일 경로를 찾아 반환합니다.
@@ -322,8 +722,8 @@ export async function execPythonCode(python_code, args = [], timeoutMs = 1200000
     }
 }
 
-// 쉘 스크립트를 임시 파일로 만들어 안전하게 실행합니다.
-// 파이썬 실행과 동일하게 Orchestrator의 지시에 따라 반복적으로 호출됩니다.
+// 쉘 스크립트를 PersistentShell을 통해 실행합니다.
+// 쉘 세션이 유지되므로 cd, 환경변수 등의 상태가 보존됩니다.
 export async function execShellScript(script, timeoutMs = 1200000) {
     debugLog('========================================');
     debugLog('====== execShellScript START ===========');
@@ -332,99 +732,96 @@ export async function execShellScript(script, timeoutMs = 1200000) {
     debugLog(`[execShellScript] Script preview (first 200 chars): ${script.substring(0, 200)}${script.length > 200 ? '...' : ''}`);
     debugLog(`[execShellScript] Timeout: ${timeoutMs}ms`);
 
-    // Intentional delay for testing pending state
-    await new Promise(resolve => setTimeout(resolve, 13));
+    const shell = getPersistentShell();
+
+    try {
+        const result = await shell.exec(script, timeoutMs);
+
+        debugLog(`[execShellScript] Execution complete`);
+        debugLog(`[execShellScript] Exit code: ${result.code}`);
+        debugLog(`[execShellScript] Stdout length: ${result.stdout.length} bytes`);
+        debugLog(`[execShellScript] Stderr length: ${result.stderr.length} bytes`);
+        debugLog(`[execShellScript] Timed out: ${result.timeout}`);
+        if (result.stdout) {
+            debugLog(`[execShellScript] Stdout preview: ${result.stdout.substring(0, 500)}${result.stdout.length > 500 ? '...' : ''}`);
+        }
+        if (result.stderr) {
+            debugLog(`[execShellScript] Stderr content: ${result.stderr}`);
+        }
 
-    debugLog(`[execShellScript] Finding shell executable...`);
-    let shellPath = await whichCommand("bash") || await whichCommand("sh");
-    if (!shellPath) {
-        debugLog(`[execShellScript] ERROR: No shell found (bash/sh)`);
         debugLog('========================================');
-        debugLog('====== execShellScript END (NO SHELL) ==');
+        debugLog('====== execShellScript END =============');
         debugLog('========================================');
+        return result;
+
+    } catch (err) {
+        debugLog(`[execShellScript] EXCEPTION: ${err.message}`);
+        debugLog(`[execShellScript] Exception stack: ${err.stack}`);
+        debugLog('========================================');
+        debugLog('====== execShellScript END (ERROR) =====');
+        debugLog('========================================');
+        throw err;
+    }
+}
+
+// 기존 방식: 임시 파일로 쉘 스크립트 실행 (fallback용)
+export async function execShellScriptLegacy(script, timeoutMs = 1200000) {
+    debugLog('========================================');
+    debugLog('====== execShellScriptLegacy START =====');
+    debugLog('========================================');
+    debugLog(`[execShellScriptLegacy] Script length: ${script.length} characters`);
+
+    let shellPath = await whichCommand("bash") || await whichCommand("sh");
+    if (!shellPath) {
+        debugLog(`[execShellScriptLegacy] ERROR: No shell found (bash/sh)`);
         return null;
     }
-    debugLog(`[execShellScript] Using shell: ${shellPath}`);
 
     const tempFile = join(getTempDirPath(), `temp_${Date.now()}.sh`);
-    debugLog(`[execShellScript] Temp file path: ${tempFile}`);
 
     try {
-        // 기존 임시 파일이 있다면 삭제
         try {
             await safeAccess(tempFile);
-            debugLog(`[execShellScript] Temp file already exists, deleting...`);
             await safeUnlink(tempFile);
         } catch (err) {
-            debugLog(`[execShellScript] Temp file does not exist (normal)`);
             // 파일이 없으면 무시
         }
 
-        debugLog(`[execShellScript] Writing script to temp file...`);
         const result = await write_file({ file_path: tempFile, content: script });
         if (!result.operation_successful) {
-            debugLog(`[execShellScript] ERROR: Failed to create temp file - ${result.error}`);
             throw new Error(`Failed to create temp file: ${result.error}`);
         }
-        debugLog(`[execShellScript] Script written successfully`);
     } catch (err) {
-        debugLog(`[execShellScript] EXCEPTION during file write: ${err.message}`);
-        debugLog('========================================');
-        debugLog('====== execShellScript END (WRITE ERR) =');
-        debugLog('========================================');
+        debugLog(`[execShellScriptLegacy] EXCEPTION during file write: ${err.message}`);
         throw err;
     }
 
     try {
-        debugLog(`[execShellScript] Spawning shell process...`);
-        debugLog(`[execShellScript] Command: ${shellPath} ${tempFile}`);
-
         const shell = spawn(shellPath, [tempFile], {
-            stdio: ['ignore', 'pipe', 'pipe'], // stdin을 ignore하여 입력 프롬프트 방지
+            stdio: ['ignore', 'pipe', 'pipe'],
             env: {
                 ...process.env,
-                DEBIAN_FRONTEND: 'noninteractive', // 비대화형 모드
-                CI: 'true', // CI 환경으로 인식시켜 프롬프트 방지
-                BATCH: '1' // 배치 모드
+                DEBIAN_FRONTEND: 'noninteractive',
+                CI: 'true',
+                BATCH: '1'
             },
-            detached: true // 프로세스 그룹 생성으로 자식 프로세스까지 제어
+            detached: true
         });
 
-        debugLog(`[execShellScript] Process spawned - PID: ${shell.pid}`);
-        debugLog(`[execShellScript] Waiting for process to complete...`);
-
         const result = await createProcessHandler(shell, tempFile, timeoutMs);
 
-        debugLog(`[execShellScript] Execution complete`);
-        debugLog(`[execShellScript] Exit code: ${result.code}`);
-        debugLog(`[execShellScript] Stdout length: ${result.stdout.length} bytes`);
-        debugLog(`[execShellScript] Stderr length: ${result.stderr.length} bytes`);
-        debugLog(`[execShellScript] Timed out: ${result.timeout}`);
-        if (result.stdout) {
-            debugLog(`[execShellScript] Stdout preview: ${result.stdout.substring(0, 500)}${result.stdout.length > 500 ? '...' : ''}`);
-        }
-        if (result.stderr) {
-            debugLog(`[execShellScript] Stderr content: ${result.stderr}`);
-        }
-
         debugLog('========================================');
-        debugLog('====== execShellScript END =============');
+        debugLog('====== execShellScriptLegacy END =======');
         debugLog('========================================');
         return result;
 
     } catch (err) {
-        debugLog(`[execShellScript] EXCEPTION: ${err.message}`);
-        debugLog(`[execShellScript] Exception stack: ${err.stack}`);
+        debugLog(`[execShellScriptLegacy] EXCEPTION: ${err.message}`);
         try {
             await safeUnlink(tempFile);
-            debugLog(`[execShellScript] Cleaned up temp file after error`);
         } catch (unlinkErr) {
-            debugLog(`[execShellScript] Failed to delete temp file: ${unlinkErr.message}`);
+            // ignore
         }
-
-        debugLog('========================================');
-        debugLog('====== execShellScript END (ERROR) =====');
-        debugLog('========================================');
         throw err;
     }
 }
@@ -581,7 +978,13 @@ export const runPythonCodeSchema = {
 
 export const bashSchema = {
     name: "bash",
-    description: `Executes bash shell commands with optional timeout.
+    description: `Executes bash shell commands in a persistent shell session.
+
+SHELL STATE PERSISTENCE:
+- Working directory (cd) is preserved across calls
+- Environment variables set with export persist
+- Shell history and state are maintained throughout the session
+- You can cd to a directory in one call and use relative paths in the next
 
 IMPORTANT: This tool is for terminal operations like git, npm, docker, etc. DO NOT use it for file reading/searching operations - use specialized tools instead.
 
@@ -609,19 +1012,28 @@ Best Practices:
 - Avoid interactive commands that require user input
 - For calculations, use non-interactive bc or Python (never mental arithmetic)
 
-This tool handles: file system operations (mkdir, rm, mv, cp, chmod), git commands, package management (npm, pip), and CLI tools.`,
+This tool handles: file system operations (mkdir, rm, mv, cp, chmod), git commands, package management (npm, pip), and CLI tools.
+
+BACKGROUND EXECUTION:
+- Set background: true to run long-running commands without blocking
+- Background processes can be monitored and killed via the UI
+- Use for: servers, watchers, long builds, or any command that doesn't need immediate output`,
     parameters: {
         type: "object",
         required: ["script"],
         properties: {
             script: {
                 type: "string",
-                description: "Bash script to execute. Will be saved to a temporary file and run with bash. Keep scripts concise and output-limited to avoid truncation."
+                description: "Bash script to execute in the persistent shell. Working directory and environment variables persist across calls."
+            },
+            background: {
+                type: "boolean",
+                description: "If true, run the command in the background. The command will continue running and can be monitored/killed later. Use for long-running processes like servers or watchers."
             }
         },
         additionalProperties: false
     },
-    strict: true,
+    strict: false,
     ui_display: {
         show_tool_call: true,
         show_tool_result: true,