aiexecode 1.0.54 → 1.0.56

package/src/system/session_memory.js

@@ -1,12 +1,11 @@
 // 세션별 실행 기록을 파일로 저장하고 로드하는 모듈
-import fs from 'fs/promises';
-import { existsSync, mkdirSync } from 'fs';
+import { safeReadFile, safeWriteFile, safeExists, safeMkdir, safeUnlink } from '../util/safe_fs.js';
 import { join, resolve } from 'path';
 import chalk from 'chalk';
 import { formatToolCall, formatToolResult, getToolDisplayName, getToolDisplayConfig } from './tool_registry.js';
 import { createDebugLogger } from '../util/debug_log.js';
 
-const MAX_HISTORY_SESSIONS = 20; // 최대 보관 세션 수
+const MAX_HISTORY_SESSIONS = 1; // 최대 보관 세션 수
 
 const debugLog = createDebugLogger('session_memory.log', 'session_memory');
 
@@ -21,11 +20,10 @@ function getHistoryFile(sessionID) {
 }
 
 // 디렉토리 생성 확인
-function ensureHistoryDir(sessionID) {
+async function ensureHistoryDir(sessionID) {
     const sessionDir = getSessionDir(sessionID);
-    if (!existsSync(sessionDir)) {
-        mkdirSync(sessionDir, { recursive: true });
-    }
+    // recursive: true 이므로 이미 존재해도 에러 없음
+    await safeMkdir(sessionDir, { recursive: true });
 }
 
 function consolelog() { }
@@ -38,9 +36,8 @@ function consolelog() { }
 export async function deleteHistoryFile(sessionID) {
     try {
         const historyFile = getHistoryFile(sessionID);
-        if (existsSync(historyFile)) {
-            await fs.unlink(historyFile);
-        }
+        // safeUnlink 내부에서 파일 존재 여부를 체크하므로 중복 체크 불필요
+        await safeUnlink(historyFile);
     } catch (err) {
     }
 }
@@ -52,10 +49,10 @@ export async function deleteHistoryFile(sessionID) {
  */
 export async function loadPreviousSessions(sessionID) {
     try {
-        ensureHistoryDir(sessionID);
+        await ensureHistoryDir(sessionID);
         const historyFile = getHistoryFile(sessionID);
-        if (existsSync(historyFile)) {
-            const content = await fs.readFile(historyFile, 'utf8');
+        if (await safeExists(historyFile)) {
+            const content = await safeReadFile(historyFile, 'utf8');
             const sessions = JSON.parse(content);
             // consolelog(chalk.blue(`📚 Loaded ${sessions.length} previous sessions from history`));
             return sessions;
@@ -74,20 +71,45 @@ export async function loadPreviousSessions(sessionID) {
 export async function saveSessionToHistory(sessionData) {
     try {
         const sessionID = sessionData.sessionID || process.app_custom.sessionID;
-        ensureHistoryDir(sessionID);
+        await ensureHistoryDir(sessionID);
         const historyFile = getHistoryFile(sessionID);
 
-        const previousSessions = sessionData.previousSessions || [];
-        const allSessions = [...previousSessions, sessionData];
+        debugLog('========== saveSessionToHistory START ==========');
+        debugLog(`sessionID: ${sessionID}`);
+        debugLog(`historyFile: ${historyFile}`);
+
+        // 파일에서 이전 세션들을 로드 (메모리 누적 방지)
+        const previousSessions = (await safeExists(historyFile))
+            ? JSON.parse(await safeReadFile(historyFile, 'utf8'))
+            : [];
+
+        debugLog(`previousSessions loaded from file: ${previousSessions.length} sessions`);
 
-        // 최대 개수 제한
+        // sessionData에서 previousSessions 제거 (중복 저장 방지)
+        const { previousSessions: _, ...sessionToSave } = sessionData;
+
+        debugLog(`sessionToSave size: ${JSON.stringify(sessionToSave).length} bytes`);
+
+        const allSessions = [...previousSessions, sessionToSave];
+        debugLog(`allSessions total: ${allSessions.length} sessions`);
+
+        // 최대 개수 제한 (fileSnapshot은 UI 표시를 위해 모두 유지)
         const sessionsToKeep = allSessions.length > MAX_HISTORY_SESSIONS
             ? allSessions.slice(-MAX_HISTORY_SESSIONS)
             : allSessions;
 
-        await fs.writeFile(historyFile, JSON.stringify(sessionsToKeep, null, 2), 'utf8');
+        debugLog(`sessionsToKeep: ${sessionsToKeep.length} sessions`);
+        const totalSize = JSON.stringify(sessionsToKeep).length;
+        debugLog(`Total file size to write: ${totalSize} bytes (${(totalSize / 1024).toFixed(2)} KB)`);
+
+        await safeWriteFile(historyFile, JSON.stringify(sessionsToKeep, null, 2), 'utf8');
+        debugLog('File written successfully');
+        debugLog('========== saveSessionToHistory END ==========');
+
         return sessionsToKeep;
     } catch (err) {
+        debugLog(`ERROR in saveSessionToHistory: ${err.message}`);
+        debugLog(`Stack: ${err.stack}`);
     }
     return null;
 }
@@ -262,14 +284,6 @@ export function reconstructUIHistory(sessions) {
             debugLog(`toolUsageHistory items: ${session.toolUsageHistory.length}`);
         }
 
-        // 미션 시작
-        uiHistory.push({
-            type: 'user',
-            text: session.mission,
-            timestamp: new Date(session.started_at).getTime()
-        });
-        debugLog(`Added user mission to uiHistory (index ${uiHistory.length - 1})`);
-
         // orchestratorConversation에서 도구 사용 이벤트 추출
         // 이전 세션까지의 대화 길이를 계산하여 중복 제거
         if (session.orchestratorConversation && session.orchestratorConversation.length > 0) {
@@ -462,6 +476,18 @@ export function reconstructUIHistory(sessions) {
                         });
                     }
                 }
+
+                // user 메시지 타입 처리
+                if (item.role === 'user' && item.content) {
+                    const textContent = item.content.find(c => c.type === 'input_text');
+                    if (textContent && textContent.text) {
+                        uiHistory.push({
+                            type: 'user',
+                            text: textContent.text,
+                            timestamp: Date.now()
+                        });
+                    }
+                }
             }
         }
 

package/src/tools/code_editor.js

@@ -1,4 +1,4 @@
-import { promises as fs } from 'fs';
+import { safeReadFile, safeWriteFile, safeAccess, safeMkdir, safeAppendFile } from '../util/safe_fs.js';
 import { dirname, resolve, join } from 'path';
 import * as diff from 'diff';
 import { assertFileIntegrity, trackFileRead, saveFileSnapshot } from '../system/file_integrity.js';
@@ -62,12 +62,12 @@ export async function write_file({ file_path, content }) {
 
         // 디렉토리가 존재하지 않으면 생성
         try {
-            await fs.access(dir);
+            await safeAccess(dir);
             internalDebugLog.push(`[${timestamp}] Directory exists`);
             debugLog(`Directory exists`);
         } catch (error) {
-            if (error.code === 'ENOENT') {
-                await fs.mkdir(dir, { recursive: true });
+            if (error.message.includes('ENOENT') || error.message.includes('does not exist')) {
+                await safeMkdir(dir, { recursive: true });
                 internalDebugLog.push(`[${timestamp}] Directory created`);
                 debugLog(`Directory created`);
             } else {
@@ -80,13 +80,13 @@ export async function write_file({ file_path, content }) {
         let fileExists = false;
         debugLog(`Checking if file exists...`);
         try {
-            originalContent = await fs.readFile(absolutePath, 'utf8');
+            originalContent = await safeReadFile(absolutePath, 'utf8');
             fileExists = true;
             internalDebugLog.push(`[${timestamp}] File EXISTS - size: ${originalContent.length} bytes`);
             debugLog(`File EXISTS - size: ${originalContent.length} bytes`);
             debugLog(`Original content first 100 chars: ${JSON.stringify(originalContent.substring(0, 100))}`);
         } catch (error) {
-            if (error.code !== 'ENOENT') {
+            if (!error.message.includes('ENOENT') && !error.message.includes('no such file')) {
                 throw error;
             }
             internalDebugLog.push(`[${timestamp}] File DOES NOT EXIST`);
@@ -105,8 +105,8 @@ export async function write_file({ file_path, content }) {
                 internalDebugLog.push(`[${timestamp}] assertFileIntegrity FAILED: ${integrityError.message}`);
                 debugLog(`ERROR: assertFileIntegrity FAILED: ${integrityError.message}`);
                 const logFile = getLogFile();
-                await fs.mkdir(dirname(logFile), { recursive: true }).catch(() => {});
-                await fs.appendFile(logFile, internalDebugLog.join('\n') + '\n');
+                await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
+                await safeAppendFile(logFile, internalDebugLog.join('\n') + '\n');
                 throw integrityError;
             }
         }
@@ -114,7 +114,7 @@ export async function write_file({ file_path, content }) {
         // 파일 쓰기 (절대경로 사용)
         internalDebugLog.push(`[${timestamp}] Writing file - content size: ${content.length} bytes`);
         debugLog(`Writing file - content size: ${content.length} bytes`);
-        await fs.writeFile(absolutePath, content, 'utf8');
+        await safeWriteFile(absolutePath, content, 'utf8');
         internalDebugLog.push(`[${timestamp}] File written successfully`);
         debugLog(`File written successfully`);
 
@@ -130,8 +130,8 @@ export async function write_file({ file_path, content }) {
         debugLog(`Snapshot saved`);
 
         const logFile = getLogFile();
-        await fs.mkdir(dirname(logFile), { recursive: true }).catch(() => {});
-        await fs.appendFile(logFile, internalDebugLog.join('\n') + '\n');
+        await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
+        await safeAppendFile(logFile, internalDebugLog.join('\n') + '\n');
 
         // diff 생성 (기존 파일이 있었을 경우에만, 절대경로 사용)
         let diffInfo = null;
@@ -176,8 +176,8 @@ export async function write_file({ file_path, content }) {
         debugLog(`Stack trace: ${error.stack}`);
         debugLog('========== write_file EXCEPTION END ==========');
         const logFile = getLogFile();
-        await fs.mkdir(dirname(logFile), { recursive: true }).catch(() => {});
-        await fs.appendFile(logFile, internalDebugLog.join('\n') + '\n').catch(() => {});
+        await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
+        await safeAppendFile(logFile, internalDebugLog.join('\n') + '\n').catch(() => {});
 
         // 에러 시에도 절대경로로 반환
         const absolutePath = resolve(file_path);
@@ -272,10 +272,10 @@ export async function edit_file_replace({ file_path, old_string, new_string }) {
 
         // 파일 존재 확인
         try {
-            await fs.access(absolutePath);
+            await safeAccess(absolutePath);
             debugLog(`File access OK`);
         } catch (error) {
-            if (error.code === 'ENOENT') {
+            if (error.message.includes('ENOENT') || error.message.includes('no such file')) {
                 debugLog(`ERROR: File not found`);
                 return {
                     operation_successful: false,
@@ -293,7 +293,7 @@ export async function edit_file_replace({ file_path, old_string, new_string }) {
 
         // 원본 파일 읽기 (절대경로 사용)
         debugLog(`Reading file content...`);
-        const originalContent = await fs.readFile(absolutePath, 'utf8');
+        const originalContent = await safeReadFile(absolutePath, 'utf8');
         debugLog(`File read successful:`);
         debugLog(`  Content length: ${originalContent.length} bytes`);
         debugLog(`  Line count: ${originalContent.split('\n').length}`);
@@ -415,7 +415,7 @@ export async function edit_file_replace({ file_path, old_string, new_string }) {
 
         // 파일 저장 (절대경로 사용)
         debugLog(`Writing file...`);
-        await fs.writeFile(absolutePath, newContent, 'utf8');
+        await safeWriteFile(absolutePath, newContent, 'utf8');
         debugLog(`File written successfully`);
 
         // 파일 수정 후 해시 업데이트 (절대경로 사용)
@@ -509,10 +509,10 @@ export async function edit_file_range({ file_path, start_line, end_line, new_con
         // 파일 존재 확인
         debugLog(`Checking if file exists...`);
         try {
-            await fs.access(absolutePath);
+            await safeAccess(absolutePath);
             debugLog(`File access OK`);
         } catch (error) {
-            if (error.code === 'ENOENT') {
+            if (error.message.includes('ENOENT') || error.message.includes('no such file')) {
                 debugLog(`ERROR: File not found`);
                 debugLog('========== edit_file_range ERROR END ==========');
                 return {
@@ -531,7 +531,7 @@ export async function edit_file_range({ file_path, start_line, end_line, new_con
 
         // 원본 파일 읽기 (절대경로 사용)
         debugLog(`Reading file content...`);
-        const originalContent = await fs.readFile(absolutePath, 'utf8');
+        const originalContent = await safeReadFile(absolutePath, 'utf8');
         debugLog(`File read successful:`);
         debugLog(`  Content length: ${originalContent.length} bytes`);
         debugLog(`  Line count: ${originalContent.split('\n').length}`);
@@ -632,7 +632,7 @@ export async function edit_file_range({ file_path, start_line, end_line, new_con
 
         // 파일 저장 (절대경로 사용)
         debugLog(`Writing file...`);
-        await fs.writeFile(absolutePath, newFileContent, 'utf8');
+        await safeWriteFile(absolutePath, newFileContent, 'utf8');
         debugLog(`File written successfully`);
 
         // 파일 수정 후 해시 업데이트 (절대경로 사용)

package/src/tools/file_reader.js

@@ -1,4 +1,4 @@
-import { promises as fs } from 'fs';
+import { safeReadFile } from '../util/safe_fs.js';
 import { resolve } from 'path';
 import { trackFileRead, saveFileSnapshot } from '../system/file_integrity.js';
 import { createDebugLogger } from '../util/debug_log.js';
@@ -41,7 +41,7 @@ export async function read_file({ filePath }) {
         debugLog(`  - Absolute path length: ${absolutePath.length}`);
 
         debugLog(`Reading file...`);
-        const content = await fs.readFile(absolutePath, 'utf8');
+        const content = await safeReadFile(absolutePath, 'utf8');
         debugLog(`File read successful: ${content.length} bytes`);
 
         const lines = content.split('\n');
@@ -168,7 +168,7 @@ export async function read_file_range({ filePath, startLine, endLine }) {
 
         // 파일 전체를 읽고 범위만 추출
         debugLog(`Reading file...`);
-        const content = await fs.readFile(absolutePath, 'utf8');
+        const content = await safeReadFile(absolutePath, 'utf8');
         debugLog(`File read successful: ${content.length} bytes`);
 
         const lines = content.split('\n');

package/src/tools/glob.js

@@ -1,6 +1,6 @@
 import { glob } from 'glob';
 import { resolve, relative } from 'path';
-import { promises as fs } from 'fs';
+import { safeStat } from '../util/safe_fs.js';
 import { createDebugLogger } from '../util/debug_log.js';
 
 const debugLog = createDebugLogger('glob.log', 'glob');

package/src/tools/web_downloader.js

@@ -1,5 +1,5 @@
 import { execPythonCode } from "../system/code_executer.js";
-import fs from 'fs';
+import { safeReadFile } from '../util/safe_fs.js';
 import { join } from 'path';
 
 // 이 파일은 웹 페이지를 가져와서 텍스트 형식으로 변환하는 도구를 제공합니다.
@@ -21,7 +21,7 @@ export async function fetch_web_page({ url }) {
     const timeout = 30;
     const user_agent = 'Mozilla/5.0 (compatible; WebFetcher/1.0)';
     const encoding = 'utf-8';
-    const pythonCode = await fs.promises.readFile(join(process.app_custom?.__dirname || process.cwd(), 'src', 'tools', 'web_download.py'), 'utf8');
+    const pythonCode = await safeReadFile(join(process.app_custom?.__dirname || process.cwd(), 'src', 'tools', 'web_download.py'), 'utf8');
     const result = await execPythonCode(pythonCode, [url, timeout, user_agent, encoding]);
 
     return {

package/src/ui/components/HistoryItemDisplay.js

@@ -11,7 +11,7 @@ import { renderMarkdown } from '../utils/markdownRenderer.js';
 import { FileDiffViewer } from './FileDiffViewer.js';
 import { getToolDisplayName, formatToolCall } from '../../system/tool_registry.js';
 import { getFileSnapshot } from '../../system/file_integrity.js';
-import fs from 'fs';
+import { safeMkdir, safeAppendFile } from '../../util/safe_fs.js';
 import { resolve, join, dirname } from 'path';
 import { DEBUG_LOG_DIR } from '../../util/config.js';
 import { createHash } from 'crypto';
@@ -25,9 +25,6 @@ const OLDSTRING_LOG_FILE = join(DEBUG_LOG_DIR, 'oldstring.txt');
 function logOldStringEvidence(evidence) {
     try {
         const dir = dirname(OLDSTRING_LOG_FILE);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
         const timestamp = new Date().toISOString();
         const separator = '\n' + '='.repeat(80) + '\n';
 
@@ -62,7 +59,16 @@ function logOldStringEvidence(evidence) {
         logEntry += `\n--- Result Args ---\n`;
         logEntry += JSON.stringify(evidence.resultArgs, null, 2) + '\n';
 
-        fs.appendFileSync(OLDSTRING_LOG_FILE, logEntry);
+        // Convert sync operations to async (non-blocking)
+        setImmediate(async () => {
+            try {
+                // 디렉토리가 없으면 생성 (recursive: true 이므로 이미 존재해도 에러 없음)
+                await safeMkdir(dir, { recursive: true });
+                await safeAppendFile(OLDSTRING_LOG_FILE, logEntry);
+            } catch (err) {
+                // Ignore logging errors
+            }
+        });
     } catch (err) {
         // Ignore logging errors
     }

package/src/util/config.js

@@ -1,7 +1,7 @@
 // 설정 파일 및 환경 관리 유틸리티
 import { homedir } from 'os';
 import { join, dirname } from 'path';
-import { promises as fs } from 'fs';
+import { safeReadFile, safeWriteFile, safeMkdir, safeReaddir, safeStat, safeCopyFile } from './safe_fs.js';
 import { fileURLToPath } from 'url';
 import { DEFAULT_CLAUDE_MODEL } from '../config/claude_models.js';
 import { DEFAULT_OPENAI_MODEL } from '../config/openai_models.js';
@@ -71,20 +71,20 @@ const DEFAULT_SETTINGS = {
  */
 export async function ensureConfigDirectory() {
     try {
-        const created = await fs.mkdir(CONFIG_DIR, { recursive: true });
+        const created = await safeMkdir(CONFIG_DIR, { recursive: true });
         if (!created) return;
 
         const templateDir = process.app_custom?.__dirname ? join(process.app_custom.__dirname, 'config_template') : null;
         if (!templateDir) return;
 
-        const templateFiles = await fs.readdir(templateDir);
+        const templateFiles = await safeReaddir(templateDir);
         await Promise.all(
             templateFiles.map(async (fileName) => {
                 const sourcePath = join(templateDir, fileName);
-                const stat = await fs.stat(sourcePath);
+                const stat = await safeStat(sourcePath);
                 if (stat.isFile()) {
                     const destPath = join(CONFIG_DIR, fileName);
-                    await fs.copyFile(sourcePath, destPath);
+                    await safeCopyFile(sourcePath, destPath);
                 }
             })
         );
@@ -101,15 +101,15 @@ export async function ensureConfigDirectory() {
 export async function loadSettings() {
     await ensureConfigDirectory();
     try {
-        const data = await fs.readFile(SETTINGS_FILE, 'utf8');
+        const data = await safeReadFile(SETTINGS_FILE, 'utf8');
         const parsed = JSON.parse(data);
         return {
             ...DEFAULT_SETTINGS,
             ...(parsed && typeof parsed === 'object' ? parsed : {})
         };
     } catch (error) {
-        if (error.code === 'ENOENT') {
-            await fs.writeFile(SETTINGS_FILE, JSON.stringify(DEFAULT_SETTINGS, null, 2), 'utf8');
+        if (error.message && error.message.includes('Failed to read file')) {
+            await safeWriteFile(SETTINGS_FILE, JSON.stringify(DEFAULT_SETTINGS, null, 2), 'utf8');
             return { ...DEFAULT_SETTINGS };
         }
         consolelog(`Failed to load settings from ${SETTINGS_FILE}:`, error);
@@ -125,7 +125,7 @@ export async function loadSettings() {
 export async function saveSettings(settings) {
     await ensureConfigDirectory();
     try {
-        await fs.writeFile(SETTINGS_FILE, JSON.stringify(settings, null, 2), 'utf8');
+        await safeWriteFile(SETTINGS_FILE, JSON.stringify(settings, null, 2), 'utf8');
     } catch (error) {
         consolelog(`Failed to save settings to ${SETTINGS_FILE}:`, error);
         throw error;

package/src/util/debug_log.js

@@ -5,7 +5,7 @@
 
 import { DEBUG_LOG_DIR } from './config.js';
 import { join, dirname } from 'path';
-import { appendFileSync, existsSync, mkdirSync } from 'fs';
+import { safeMkdir, safeAppendFile } from './safe_fs.js';
 
 /**
  * 디버그 로그를 파일에 기록합니다.
@@ -19,16 +19,21 @@ export function debugLog(logFileName, context, message) {
         const LOG_FILE = join(DEBUG_LOG_DIR, logFileName);
         const logDir = dirname(LOG_FILE);
 
-        if (!existsSync(logDir)) {
-            mkdirSync(logDir, { recursive: true });
-        }
-
         const timestamp = new Date().toISOString();
         const logMessage = context
             ? `[${timestamp}] [${context}] ${message}\n`
             : `[${timestamp}] ${message}\n`;
 
-        appendFileSync(LOG_FILE, logMessage);
+        // 디렉토리 생성 및 로그 쓰기를 비동기로 처리
+        setImmediate(async () => {
+            try {
+                // 디렉토리가 없으면 생성 (recursive: true 이므로 이미 존재해도 에러 없음)
+                await safeMkdir(logDir, { recursive: true });
+                await safeAppendFile(LOG_FILE, logMessage);
+            } catch (err) {
+                // Ignore logging errors
+            }
+        });
     } catch (err) {
         // Ignore logging errors
     }

package/src/util/mcp_config_manager.js

@@ -1,5 +1,5 @@
 // MCP 설정 관리 유틸리티 - Claude Code 스타일
-import { promises as fs } from 'fs';
+import { safeReadFile, safeWriteFile, safeMkdir } from './safe_fs.js';
 import { join } from 'path';
 import { createHash } from 'crypto';
 import { CONFIG_DIR } from './config.js';
@@ -22,14 +22,14 @@ export function getMcpConfigPath() {
 export async function loadMergedMcpConfig() {
     try {
         const path = getMcpConfigPath();
-        const data = await fs.readFile(path, 'utf8');
+        const data = await safeReadFile(path, 'utf8');
         const config = JSON.parse(data);
 
         consolelog(`Loaded MCP config from ${path}`);
         return config.mcpServers || {};
     } catch (error) {
         // 파일이 없으면 빈 객체 반환
-        if (error.code === 'ENOENT') {
+        if (error.message && error.message.includes('Failed to read file')) {
             return {};
         }
         consolelog(`Warning: Failed to load MCP config: ${error.message}`);
@@ -76,13 +76,13 @@ export async function saveMcpConfig(servers) {
     const path = getMcpConfigPath();
     const dir = join(path, '..');
 
-    await fs.mkdir(dir, { recursive: true });
+    await safeMkdir(dir, { recursive: true });
 
     const config = {
         mcpServers: servers
     };
 
-    await fs.writeFile(path, JSON.stringify(config, null, 2), 'utf8');
+    await safeWriteFile(path, JSON.stringify(config, null, 2), 'utf8');
     consolelog(`Saved MCP config to ${path}`);
     return path;
 }

package/src/util/output_formatter.js

@@ -1,5 +1,5 @@
 // 도구 실행 결과를 사람이 읽기 쉬운 형태로 포맷팅하는 유틸리티 함수들
-import fs from 'fs';
+// fs module is imported but not used in this file
 
 /**
  * 텍스트를 안전한 문자열로 변환

package/src/util/prompt_loader.js

@@ -1,4 +1,4 @@
-import { readFile, access } from "fs/promises";
+import { safeReadFile, safeAccess } from "./safe_fs.js";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 
@@ -21,7 +21,7 @@ export function getProjectRoot() {
  */
 async function loadSystemPrompt(promptPath) {
     try {
-        const content = await readFile(promptPath, "utf8");
+        const content = await safeReadFile(promptPath, "utf8");
         return content.trim();
     } catch (error) {
         consolelog(`Failed to load system prompt from ${promptPath}:`, error);
@@ -36,7 +36,7 @@ async function loadSystemPrompt(promptPath) {
  */
 async function fileExists(filePath) {
     try {
-        await access(filePath);
+        await safeAccess(filePath);
         return true;
     } catch {
         return false;