aiexecode 1.0.157

package/src/util/safe_fs.js

@@ -0,0 +1,645 @@
+/**
+ * Safe File System Operations Wrapper
+ *
+ * 이 모듈은 파일 시스템의 파괴적 작업들을 안전하게 수행하기 위한 wrapper 함수들을 제공합니다.
+ * 모든 파괴적 작업은 검증과 에러 핸들링을 포함합니다.
+ */
+
+import fs from 'fs/promises';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+
+// 허용된 디렉토리들
+const ALLOWED_DIRECTORIES = [
+    process.cwd(), // current working directory
+    path.join(homedir(), '.aiexe') // ~/.aiexe
+];
+
+// 설정 파일 경로 (config.js와 동일하게 계산, 순환 참조 방지)
+const SETTINGS_FILE = path.join(homedir(), '.aiexe', 'settings.json');
+
+/**
+ * 디버그 모드 활성화 여부 확인 (순환 참조 방지를 위해 직접 구현)
+ * @returns {boolean}
+ */
+function isDebugEnabled() {
+    try {
+        const data = readFileSync(SETTINGS_FILE, 'utf8');
+        const parsed = JSON.parse(data);
+        return parsed?.SHOW_API_PAYLOAD === true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * 파일/디렉토리 존재 여부 확인 (비동기)
+ * @param {string} filePath - 확인할 경로
+ * @returns {Promise<boolean>}
+ */
+async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function debugLog(str) {
+    // 디버그 모드가 꺼져있으면 로그를 기록하지 않음
+    if (!isDebugEnabled()) {
+        return;
+    }
+
+    const logDir = path.join(homedir(), '.aiexe', 'debuglog');
+    const logFile = path.join(logDir, 'safe_fs.log');
+
+    if (!(await exists(logDir))) {
+        await fs.mkdir(logDir, { recursive: true }).catch(() => {});
+    }
+
+    await fs.appendFile(logFile, str).catch(() => {});
+}
+
+
+/**
+ * 경로를 절대경로로 변환
+ * @param {string} filePath - 변환할 파일 경로
+ * @returns {string} 절대 경로
+ */
+function toAbsolutePath(filePath) {
+    if (!filePath || typeof filePath !== 'string') {
+        return filePath;
+    }
+
+    // 이미 절대 경로이면 그대로 반환
+    if (path.isAbsolute(filePath)) {
+        return path.normalize(filePath);
+    }
+
+    // 상대 경로를 절대 경로로 변환
+    return path.resolve(process.cwd(), filePath);
+}
+
+/**
+ * 경로 유효성 검증
+ * @param {string} filePath - 검증할 파일 경로
+ * @returns {boolean} 유효한 경로인지 여부
+ */
+function validatePath(filePath) {
+    if (!filePath || typeof filePath !== 'string') {
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * 경로가 허용된 디렉토리 내부에 있는지 확인 (symlink 공격 방지)
+ * @param {string} filePath - 확인할 파일 경로
+ * @returns {Promise<boolean>} 허용된 디렉토리 내부에 있는지 여부
+ */
+async function isWithinAllowedDirectoryAsync(filePath) {
+    try {
+        // 실제 경로로 해석하여 symlink 공격 방지
+        const realPath = await fs.realpath(path.resolve(filePath));
+
+        return ALLOWED_DIRECTORIES.some(allowedDir => {
+            const normalizedAllowedDir = path.normalize(path.resolve(allowedDir));
+            return realPath.startsWith(normalizedAllowedDir + path.sep) ||
+                realPath === normalizedAllowedDir;
+        });
+    } catch (error) {
+        // 파일이 존재하지 않는 경우, 부모 디렉토리로 검증
+        // 새 파일 생성 시에는 파일이 아직 존재하지 않을 수 있음
+        const parentDir = path.dirname(path.resolve(filePath));
+        try {
+            const realParentPath = await fs.realpath(parentDir);
+            return ALLOWED_DIRECTORIES.some(allowedDir => {
+                const normalizedAllowedDir = path.normalize(path.resolve(allowedDir));
+                return realParentPath.startsWith(normalizedAllowedDir + path.sep) ||
+                    realParentPath === normalizedAllowedDir;
+            });
+        } catch {
+            // 부모 디렉토리도 존재하지 않는 경우 normalize된 경로로 검증
+            const normalizedPath = path.normalize(path.resolve(filePath));
+            return ALLOWED_DIRECTORIES.some(allowedDir => {
+                const normalizedAllowedDir = path.normalize(path.resolve(allowedDir));
+                return normalizedPath.startsWith(normalizedAllowedDir + path.sep) ||
+                    normalizedPath === normalizedAllowedDir;
+            });
+        }
+    }
+}
+
+/**
+ * 경로가 허용된 디렉토리 내부에 있는지 확인 (동기 버전, 후방 호환성용)
+ * @param {string} filePath - 확인할 파일 경로
+ * @returns {boolean} 허용된 디렉토리 내부에 있는지 여부
+ */
+function isWithinAllowedDirectory(filePath) {
+    const normalizedPath = path.normalize(path.resolve(filePath));
+
+    return ALLOWED_DIRECTORIES.some(allowedDir => {
+        const normalizedAllowedDir = path.normalize(path.resolve(allowedDir));
+        return normalizedPath.startsWith(normalizedAllowedDir + path.sep) ||
+            normalizedPath === normalizedAllowedDir;
+    });
+}
+
+/**
+ * 보호된 경로인지 확인 (deprecated - isWithinAllowedDirectory로 대체됨)
+ * @param {string} filePath - 확인할 파일 경로
+ * @returns {boolean} 보호된 경로인지 여부
+ */
+function isProtectedPath(filePath) {
+    // 허용된 디렉토리가 아니면 보호된 경로로 간주
+    return !isWithinAllowedDirectory(filePath);
+}
+
+/**
+ * 안전한 파일 쓰기 (symlink 공격 방지 포함)
+ * @param {string} filePath - 쓸 파일 경로
+ * @param {string|Buffer} content - 파일 내용
+ * @param {string} encoding - 인코딩 (기본값: 'utf8')
+ * @returns {Promise<void>}
+ */
+export async function safeWriteFile(filePath, content, encoding = 'utf8') {
+    const absolutePath = toAbsolutePath(filePath);
+
+    if (!validatePath(absolutePath)) {
+        const error = `Invalid file path: ${filePath}`;
+        await debugLog(`[ERROR] safeWriteFile: ${error}\n`);
+        throw new Error(error);
+    }
+
+    // symlink 공격 방지를 위해 비동기 검증 사용
+    const isAllowed = await isWithinAllowedDirectoryAsync(absolutePath);
+    if (!isAllowed) {
+        const error = `Protected path cannot be modified: ${absolutePath}`;
+        await debugLog(`[ERROR] safeWriteFile: ${error}\n`);
+        throw new Error(error);
+    }
+
+    try {
+        await fs.writeFile(absolutePath, content, encoding);
+    } catch (error) {
+        const errorMsg = `Failed to write file ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeWriteFile: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 안전한 파일 삭제
+ * @param {string} filePath - 삭제할 파일 경로
+ * @returns {Promise<void>}
+ */
+export async function safeUnlink(filePath) {
+    const absolutePath = toAbsolutePath(filePath);
+
+    if (!validatePath(absolutePath)) {
+        const error = `Invalid file path: ${filePath}`;
+        await debugLog(`[ERROR] safeUnlink: ${error}\n`);
+        throw new Error(error);
+    }
+
+    if (isProtectedPath(absolutePath)) {
+        const error = `Protected path cannot be deleted: ${absolutePath}`;
+        await debugLog(`[ERROR] safeUnlink: ${error}\n`);
+        throw new Error(error);
+    }
+
+    try {
+        if (!(await exists(absolutePath))) {
+            return; // 파일이 없으면 조용히 반환
+        }
+
+        await fs.unlink(absolutePath);
+    } catch (error) {
+        const errorMsg = `Failed to delete file ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeUnlink: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 안전한 파일 이름 변경
+ * @param {string} oldPath - 기존 파일 경로
+ * @param {string} newPath - 새 파일 경로
+ * @returns {Promise<void>}
+ */
+export async function safeRename(oldPath, newPath) {
+    const absoluteOldPath = toAbsolutePath(oldPath);
+    const absoluteNewPath = toAbsolutePath(newPath);
+
+    if (!validatePath(absoluteOldPath) || !validatePath(absoluteNewPath)) {
+        const error = `Invalid file path: ${oldPath} -> ${newPath}`;
+        await debugLog(`[ERROR] safeRename: ${error}\n`);
+        throw new Error(error);
+    }
+
+    if (isProtectedPath(absoluteOldPath) || isProtectedPath(absoluteNewPath)) {
+        const error = `Protected path cannot be modified`;
+        await debugLog(`[ERROR] safeRename: ${error} (${absoluteOldPath} -> ${absoluteNewPath})\n`);
+        throw new Error(error);
+    }
+
+    try {
+        if (!(await exists(absoluteOldPath))) {
+            const errorMsg = `Source file does not exist: ${absoluteOldPath}`;
+            await debugLog(`[ERROR] safeRename: ${errorMsg}\n`);
+            throw new Error(errorMsg);
+        }
+
+        await fs.rename(absoluteOldPath, absoluteNewPath);
+    } catch (error) {
+        const errorMsg = `Failed to rename file ${absoluteOldPath} -> ${absoluteNewPath}: ${error.message}`;
+        await debugLog(`[ERROR] safeRename: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 안전한 파일 절삭 (내용 비우기)
+ * @param {string} filePath - 절삭할 파일 경로
+ * @param {number} length - 절삭할 길이 (기본값: 0 - 파일 비우기)
+ * @returns {Promise<void>}
+ */
+export async function safeTruncate(filePath, length = 0) {
+    const absolutePath = toAbsolutePath(filePath);
+
+    if (!validatePath(absolutePath)) {
+        const error = `Invalid file path: ${filePath}`;
+        await debugLog(`[ERROR] safeTruncate: ${error}\n`);
+        throw new Error(error);
+    }
+
+    if (isProtectedPath(absolutePath)) {
+        const error = `Protected path cannot be modified: ${absolutePath}`;
+        await debugLog(`[ERROR] safeTruncate: ${error}\n`);
+        throw new Error(error);
+    }
+
+    try {
+        if (!(await exists(absolutePath))) {
+            const errorMsg = `File does not exist: ${absolutePath}`;
+            await debugLog(`[ERROR] safeTruncate: ${errorMsg}\n`);
+            throw new Error(errorMsg);
+        }
+
+        await fs.truncate(absolutePath, length);
+    } catch (error) {
+        const errorMsg = `Failed to truncate file ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeTruncate: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 안전한 디렉토리 삭제
+ * @param {string} dirPath - 삭제할 디렉토리 경로
+ * @param {Object} options - 추가 옵션
+ * @param {boolean} options.recursive - 재귀적으로 삭제 여부
+ * @returns {Promise<void>}
+ */
+export async function safeRmdir(dirPath, options = {}) {
+    const absolutePath = toAbsolutePath(dirPath);
+
+    if (!validatePath(absolutePath)) {
+        const error = `Invalid directory path: ${dirPath}`;
+        await debugLog(`[ERROR] safeRmdir: ${error}\n`);
+        throw new Error(error);
+    }
+
+    if (isProtectedPath(absolutePath)) {
+        const error = `Protected path cannot be deleted: ${absolutePath}`;
+        await debugLog(`[ERROR] safeRmdir: ${error}\n`);
+        throw new Error(error);
+    }
+
+    try {
+        if (!(await exists(absolutePath))) {
+            return; // 디렉토리가 없으면 조용히 반환
+        }
+
+        await fs.rmdir(absolutePath, options);
+    } catch (error) {
+        const errorMsg = `Failed to delete directory ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeRmdir: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 안전한 재귀적 삭제 (파일 또는 디렉토리)
+ * @param {string} targetPath - 삭제할 경로
+ * @param {Object} options - 추가 옵션
+ * @returns {Promise<void>}
+ */
+export async function safeRm(targetPath, options = {}) {
+    const absolutePath = toAbsolutePath(targetPath);
+
+    if (!validatePath(absolutePath)) {
+        const error = `Invalid path: ${targetPath}`;
+        await debugLog(`[ERROR] safeRm: ${error}\n`);
+        throw new Error(error);
+    }
+
+    if (isProtectedPath(absolutePath)) {
+        const error = `Protected path cannot be deleted: ${absolutePath}`;
+        await debugLog(`[ERROR] safeRm: ${error}\n`);
+        throw new Error(error);
+    }
+
+    try {
+        if (!(await exists(absolutePath))) {
+            return; // 경로가 없으면 조용히 반환
+        }
+
+        await fs.rm(absolutePath, { ...options, recursive: true, force: true });
+    } catch (error) {
+        const errorMsg = `Failed to remove ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeRm: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+// ============================================================
+// 읽기 전용 작업 (Read-only operations)
+// ============================================================
+
+/**
+ * 파일 읽기
+ * @param {string} filePath - 읽을 파일 경로
+ * @param {string} encoding - 인코딩 (기본값: 'utf8')
+ * @returns {Promise<string|Buffer>}
+ */
+export async function safeReadFile(filePath, encoding = 'utf8') {
+    const absolutePath = toAbsolutePath(filePath);
+
+    try {
+        return await fs.readFile(absolutePath, encoding);
+    } catch (error) {
+        const errorMsg = `Failed to read file ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeReadFile: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 파일 존재 여부 확인 (비동기)
+ * @param {string} filePath - 확인할 파일 경로
+ * @returns {Promise<boolean>}
+ */
+export async function safeExists(filePath) {
+    const absolutePath = toAbsolutePath(filePath);
+    return await exists(absolutePath);
+}
+
+/**
+ * 디렉토리 읽기
+ * @param {string} dirPath - 읽을 디렉토리 경로
+ * @param {Object} options - 추가 옵션
+ * @returns {Promise<string[]>}
+ */
+export async function safeReaddir(dirPath, options = {}) {
+    const absolutePath = toAbsolutePath(dirPath);
+
+    try {
+        return await fs.readdir(absolutePath, options);
+    } catch (error) {
+        const errorMsg = `Failed to read directory ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeReaddir: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 파일/디렉토리 상태 정보 가져오기
+ * @param {string} targetPath - 확인할 경로
+ * @returns {Promise<import('fs').Stats>}
+ */
+export async function safeStat(targetPath) {
+    const absolutePath = toAbsolutePath(targetPath);
+
+    try {
+        return await fs.stat(absolutePath);
+    } catch (error) {
+        const errorMsg = `Failed to stat ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeStat: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 파일/디렉토리 상태 정보 가져오기 (심볼릭 링크를 따라가지 않음)
+ * @param {string} targetPath - 확인할 경로
+ * @returns {Promise<import('fs').Stats>}
+ */
+export async function safeLstat(targetPath) {
+    const absolutePath = toAbsolutePath(targetPath);
+
+    try {
+        return await fs.lstat(absolutePath);
+    } catch (error) {
+        const errorMsg = `Failed to lstat ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeLstat: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 파일 접근 권한 확인
+ * @param {string} filePath - 확인할 파일 경로
+ * @param {number} mode - 접근 모드 (fs.constants.F_OK, R_OK, W_OK, X_OK)
+ * @returns {Promise<void>}
+ */
+export async function safeAccess(filePath, mode) {
+    const absolutePath = toAbsolutePath(filePath);
+
+    try {
+        return await fs.access(absolutePath, mode);
+    } catch (error) {
+        const errorMsg = `Failed to access ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeAccess: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 디렉토리 생성
+ * @param {string} dirPath - 생성할 디렉토리 경로
+ * @param {Object} options - 추가 옵션
+ * @param {boolean} options.recursive - 재귀적으로 생성 여부
+ * @returns {Promise<string|undefined>}
+ */
+export async function safeMkdir(dirPath, options = {}) {
+    const absolutePath = toAbsolutePath(dirPath);
+
+    if (!validatePath(absolutePath)) {
+        const error = `Invalid directory path: ${dirPath}`;
+        await debugLog(`[ERROR] safeMkdir: ${error}\n`);
+        throw new Error(error);
+    }
+
+    if (isProtectedPath(absolutePath)) {
+        const error = `Protected path cannot be modified: ${absolutePath}`;
+        await debugLog(`[ERROR] safeMkdir: ${error}\n`);
+        throw new Error(error);
+    }
+
+    try {
+        return await fs.mkdir(absolutePath, options);
+    } catch (error) {
+        // recursive: true 일 때 이미 존재하는 디렉토리는 에러가 아님
+        if (error.code === 'EEXIST' && options.recursive) {
+            return;
+        }
+        const errorMsg = `Failed to create directory ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeMkdir: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 실제 경로 찾기 (심볼릭 링크 해석)
+ * @param {string} targetPath - 확인할 경로
+ * @returns {Promise<string>}
+ */
+export async function safeRealpath(targetPath) {
+    const absolutePath = toAbsolutePath(targetPath);
+
+    try {
+        return await fs.realpath(absolutePath);
+    } catch (error) {
+        const errorMsg = `Failed to resolve realpath ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeRealpath: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 파일 복사
+ * @param {string} src - 원본 파일 경로
+ * @param {string} dest - 대상 파일 경로
+ * @param {number} mode - 복사 모드
+ * @returns {Promise<void>}
+ */
+export async function safeCopyFile(src, dest, mode) {
+    const absoluteSrc = toAbsolutePath(src);
+    const absoluteDest = toAbsolutePath(dest);
+
+    if (!validatePath(absoluteSrc) || !validatePath(absoluteDest)) {
+        const error = `Invalid path: ${src} -> ${dest}`;
+        await debugLog(`[ERROR] safeCopyFile: ${error}\n`);
+        throw new Error(error);
+    }
+
+    if (isProtectedPath(absoluteDest)) {
+        const error = `Protected path cannot be modified: ${absoluteDest}`;
+        await debugLog(`[ERROR] safeCopyFile: ${error}\n`);
+        throw new Error(error);
+    }
+
+    try {
+        return await fs.copyFile(absoluteSrc, absoluteDest, mode);
+    } catch (error) {
+        const errorMsg = `Failed to copy file ${absoluteSrc} -> ${absoluteDest}: ${error.message}`;
+        await debugLog(`[ERROR] safeCopyFile: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+/**
+ * 파일에 내용 추가
+ * @param {string} filePath - 파일 경로
+ * @param {string|Buffer} data - 추가할 데이터
+ * @param {string} encoding - 인코딩 (기본값: 'utf8')
+ * @returns {Promise<void>}
+ */
+export async function safeAppendFile(filePath, data, encoding = 'utf8') {
+    const absolutePath = toAbsolutePath(filePath);
+
+    if (!validatePath(absolutePath)) {
+        const error = `Invalid file path: ${filePath}`;
+        await debugLog(`[ERROR] safeAppendFile: ${error}\n`);
+        throw new Error(error);
+    }
+
+    if (isProtectedPath(absolutePath)) {
+        const error = `Protected path cannot be modified: ${absolutePath}`;
+        await debugLog(`[ERROR] safeAppendFile: ${error}\n`);
+        throw new Error(error);
+    }
+
+    try {
+        return await fs.appendFile(absolutePath, data, encoding);
+    } catch (error) {
+        const errorMsg = `Failed to append to file ${absolutePath}: ${error.message}`;
+        await debugLog(`[ERROR] safeAppendFile: ${errorMsg}\n`);
+        throw new Error(errorMsg);
+    }
+}
+
+// ============================================================
+// 동기 작업 (Synchronous operations)
+// ============================================================
+
+import { mkdirSync, appendFileSync } from 'fs';
+
+/**
+ * 디렉토리 생성 (동기)
+ * @param {string} dirPath - 생성할 디렉토리 경로
+ * @param {Object} options - 추가 옵션
+ * @param {boolean} options.recursive - 재귀적으로 생성 여부
+ * @returns {string|undefined}
+ */
+export function safeMkdirSync(dirPath, options = {}) {
+    const absolutePath = toAbsolutePath(dirPath);
+
+    if (!validatePath(absolutePath)) {
+        throw new Error(`Invalid directory path: ${dirPath}`);
+    }
+
+    if (isProtectedPath(absolutePath)) {
+        throw new Error(`Protected path cannot be modified: ${absolutePath}`);
+    }
+
+    try {
+        return mkdirSync(absolutePath, options);
+    } catch (error) {
+        // recursive: true 일 때 이미 존재하는 디렉토리는 에러가 아님
+        if (error.code === 'EEXIST' && options.recursive) {
+            return;
+        }
+        throw new Error(`Failed to create directory ${absolutePath}: ${error.message}`);
+    }
+}
+
+/**
+ * 파일에 내용 추가 (동기)
+ * @param {string} filePath - 파일 경로
+ * @param {string|Buffer} data - 추가할 데이터
+ * @param {string} encoding - 인코딩 (기본값: 'utf8')
+ * @returns {void}
+ */
+export function safeAppendFileSync(filePath, data, encoding = 'utf8') {
+    const absolutePath = toAbsolutePath(filePath);
+
+    if (!validatePath(absolutePath)) {
+        throw new Error(`Invalid file path: ${filePath}`);
+    }
+
+    if (isProtectedPath(absolutePath)) {
+        throw new Error(`Protected path cannot be modified: ${absolutePath}`);
+    }
+
+    try {
+        return appendFileSync(absolutePath, data, encoding);
+    } catch (error) {
+        throw new Error(`Failed to append to file ${absolutePath}: ${error.message}`);
+    }
+}

package/src/util/setup_wizard.js

@@ -0,0 +1,62 @@
+// 초기 설정 마법사 - 사용자에게 API 키 및 모델 설정을 안내합니다.
+import React from 'react';
+import { render } from 'ink';
+import { SetupWizard } from '../frontend/components/SetupWizard.js';
+import { loadSettings, saveSettings, SETTINGS_FILE } from './config.js';
+import chalk from 'chalk';
+
+/**
+ * 초기 설정 마법사를 실행합니다 (Ink UI 버전).
+ * @returns {Promise<boolean>} 설정 완료 여부
+ */
+export async function runSetupWizard() {
+    // 화면 클리어하고 시작
+    console.clear();
+
+    return new Promise((resolve) => {
+        let result = false;
+
+        const handleComplete = async (settings) => {
+            // 설정 저장
+            await saveSettings(settings);
+
+            result = true;
+            instance.unmount();
+
+            // 화면 클리어
+            console.clear();
+        };
+
+        const handleCancel = () => {
+            result = false;
+            instance.unmount();
+
+            // 화면 클리어
+            console.clear();
+        };
+
+        const instance = render(
+            React.createElement(SetupWizard, {
+                onComplete: handleComplete,
+                onCancel: handleCancel
+            }),
+            {
+                exitOnCtrlC: false,
+                debug: false
+            }
+        );
+
+        instance.waitUntilExit().then(() => {
+            resolve(result);
+        });
+    });
+}
+
+/**
+ * 설정이 완료되었는지 확인합니다.
+ * @returns {Promise<boolean>} 설정 완료 여부
+ */
+export async function isConfigured() {
+    const settings = await loadSettings();
+    return Boolean(settings.API_KEY && settings.API_KEY.trim());
+}