aiexecode 1.0.88 → 1.0.90

package/index.js

@@ -164,7 +164,7 @@ if (viewerMode) {
     console.log(chalk.green(`✓ Payload viewer is running`));
     console.log(chalk.yellow(`Press Ctrl+C to stop the server`));
     // Keep process alive
-    await new Promise(() => {});
+    await new Promise(() => { });
 }
 
 // 전역 설정
@@ -175,7 +175,7 @@ process.app_custom.__dirname = dirname(fileURLToPath(import.meta.url));
 // (글로벌 설치 후 aiexecode 명령으로 실행 시에는 다른 경로에서 실행됨)
 const packageJsonPath = join(process.app_custom.__dirname, 'package.json');
 const isDevelopment = existsSync(packageJsonPath) &&
-                      process.app_custom.__dirname === dirname(fileURLToPath(import.meta.url));
+    process.app_custom.__dirname === dirname(fileURLToPath(import.meta.url));
 process.env.IS_DEVELOPMENT = isDevelopment ? 'true' : 'false';
 
 // Session ID 생성 함수 (16자리 hex)
@@ -307,19 +307,100 @@ if (!process.env.OPENAI_API_KEY) {
     process.exit(1);
 }
 
-// MCP Integration 초기화 (백그라운드에서 실행)
-let mcpIntegration = null;
-let mcpToolFunctions = {};
-let mcpToolSchemas = [];
+// ========================================
+// MCP Integration 초기화
+// ========================================
+// MCP (Model Context Protocol) 서버들과의 연결을 설정하고 사용 가능한 도구 목록을 준비
+// 프로그램 시작 시 백그라운드에서 비동기로 실행되어 UI 로딩을 블로킹하지 않음
 
-// MCP 초기화를 백그라운드에서 실행하되 Promise만 저장 (이벤트는 UI 시작 후에 발생)
-const mcpInitPromise = initializeMCPIntegration(process.cwd()).then(integration => {
+let mcpIntegration = null;      // MCP Integration 인스턴스 (서버 관리 및 도구 실행)
+let mcpToolFunctions = {};      // MCP 도구 실행 함수들 (toolName -> async function)
+let mcpToolSchemas = [];        // MCP 도구 스키마들 (AI 모델에 전달할 도구 정의)
+
+// MCP 초기화를 백그라운드에서 실행
+// Promise만 저장하고 실제 UI 이벤트는 UI 시작 후에 발생시킨다
+const mcpInitPromise = initializeMCPIntegration().then(async integration => {
+    // 초기화 성공 시 결과 저장
     mcpIntegration = integration;
+
+    // MCP 도구 실행 함수들을 가져옴 (session.js에서 도구 실행 시 사용)
     mcpToolFunctions = integration ? integration.getToolFunctions() : {};
+
+    // MCP 도구 스키마들을 가져옴 (orchestrator.js에서 AI에게 전달)
     mcpToolSchemas = integration ? integration.getToolSchemas() : [];
 
+    // 초기화 결과 로깅
     if (integration) {
         const servers = integration.getConnectedServers();
+        const logLines = [];
+
+        logLines.push('');
+        logLines.push(`MCP INTEGRATION COMPLETE`);
+        logLines.push(`Timestamp: ${new Date().toISOString()}`);
+        logLines.push(`Total Servers: ${servers.length}`);
+        logLines.push(`Total Tools: ${Object.keys(mcpToolFunctions).length}`);
+        logLines.push(`Total Schemas: ${mcpToolSchemas.length}`);
+        logLines.push('');
+
+        // MCP 서버별 상세 정보
+        if (servers.length > 0) {
+            logLines.push('Connected MCP Servers:');
+            servers.forEach((server, idx) => {
+                if (idx > 0) logLines.push('');
+                logLines.push(`[${idx + 1}] ${server.name}`);
+                logLines.push(`    Status: ${server.status}`);
+                logLines.push(`    Tool Count: ${server.toolCount}`);
+                if (server.transport) {
+                    logLines.push(`    Transport: ${JSON.stringify(server.transport, null, 2).split('\n').join('\n    ')}`);
+                }
+                if (server.tools && server.tools.length > 0) {
+                    logLines.push(`    Available Tools:`);
+                    server.tools.forEach(tool => {
+                        logLines.push(`      - ${tool.name}: ${tool.description || 'No description'}`);
+                    });
+                }
+            });
+            logLines.push('');
+        }
+
+        // mcpToolFunctions 구조 로깅
+        if (Object.keys(mcpToolFunctions).length > 0) {
+            logLines.push('MCP Tool Functions:');
+            Object.keys(mcpToolFunctions).forEach((toolName, idx) => {
+                const func = mcpToolFunctions[toolName];
+                logLines.push(`  [${idx + 1}] ${toolName}`);
+                logLines.push(`      Type: ${typeof func}`);
+                logLines.push(`      Function Name: ${func?.name || 'anonymous'}`);
+            });
+            logLines.push('');
+        }
+
+        // mcpToolSchemas 구조 로깅
+        if (mcpToolSchemas.length > 0) {
+            logLines.push('MCP Tool Schemas:');
+            mcpToolSchemas.forEach((schema, idx) => {
+                logLines.push(`  [${idx + 1}] ${schema.name}`);
+                logLines.push(`      Description: ${schema.description || 'No description'}`);
+                if (schema.inputSchema) {
+                    const props = schema.inputSchema.properties || {};
+                    const propCount = Object.keys(props).length;
+                    logLines.push(`      Input Properties: ${propCount}`);
+                    if (propCount > 0) {
+                        Object.entries(props).forEach(([key, value]) => {
+                            const required = schema.inputSchema.required?.includes(key) ? ' (required)' : '';
+                            logLines.push(`        - ${key}: ${value.type || 'unknown'}${required}`);
+                        });
+                    }
+                }
+            });
+            logLines.push('');
+        }
+
+        // 별도 파일에 기록 (createDebugLogger 사용)
+        const mcpLogger = createDebugLogger('mcp_initialization.log', 'MCP');
+        logLines.forEach(line => mcpLogger(line));
+
+        // 기존 디버그 로그에도 간략하게 출력
         debugLog(`MCP integration complete: ${servers.length} server(s), ${Object.keys(mcpToolFunctions).length} tool(s)`);
         servers.forEach(server => {
             debugLog(`   - ${server.name}: ${server.toolCount} tool(s) (${server.status})`);
@@ -327,16 +408,28 @@ const mcpInitPromise = initializeMCPIntegration(process.cwd()).then(integration
     }
     return integration;
 }).catch(err => {
+    // 초기화 실패 시에도 프로그램은 계속 실행 (MCP 없이도 동작)
     debugLog(`MCP initialization failed: ${err.message}`);
     return null;
 });
 
+// ========================================
 // 커맨드 레지스트리 초기화
+// ========================================
+// 사용자가 입력하는 슬래시 커맨드들(/mcp, /exit 등)을 관리
 const commandRegistry = new CommandRegistry();
-await loadCommands(commandRegistry, {
+
+// context 객체를 생성 - getter를 사용하여 mcpIntegration을 동적으로 참조
+// 이렇게 하면 나중에 MCP가 초기화되어도 최신 값을 참조할 수 있음
+const commandContext = {
     commandRegistry,
-    mcpIntegration
-});
+    get mcpIntegration() {
+        return mcpIntegration;  // 현재 mcpIntegration 값을 반환 (null이거나 초기화된 값)
+    }
+};
+
+// src/commands/ 디렉토리의 모든 커맨드 파일들을 자동으로 로드하고 등록
+await loadCommands(commandRegistry, commandContext);
 
 // 커맨드 목록 준비
 const commandList = Array.from(commandRegistry.commands.entries()).map(([name, cmd]) => ({
@@ -364,13 +457,14 @@ async function handleSubmit(text) {
         return;
     }
 
-    // 세션 실행 (시작/종료 알림 및 저장은 runSession 내부에서 처리)
+    // 세션 실행 (AI Agent의 미션 수행)
+    // 시작/종료 알림 및 저장은 runSession 내부에서 처리
     try {
         await runSession({
-            mission: text,
-            maxIterations: 50,
-            mcpToolSchemas,
-            mcpToolFunctions
+            mission: text,           // 사용자가 입력한 미션
+            maxIterations: 50,       // 최대 반복 횟수
+            mcpToolSchemas,          // AI 모델에 전달할 MCP 도구 스키마들
+            mcpToolFunctions         // 실제 MCP 도구 실행 함수들
         });
     } catch (err) {
         // API 인증 에러 등 세션 실행 중 발생한 에러를 history에 표시
@@ -483,23 +577,34 @@ uiInstance = startUI({
     updateInfo: null // 초기에는 null, 나중에 업데이트됨
 });
 
-// UI가 시작된 후 로딩 태스크 추가
+// ========================================
+// 백그라운드 초기화 태스크 UI 연동
+// ========================================
+// UI가 시작된 후 백그라운드에서 실행 중인 초기화 작업들을 사용자에게 표시
+
+// 버전 체크 로딩 표시
 uiEvents.emit('loading:task_add', {
     id: 'version_check',
     text: 'Checking for updates...'
 });
 
+// MCP 초기화 로딩 표시
 uiEvents.emit('loading:task_add', {
     id: 'mcp_init',
     text: 'Initializing MCP servers...'
 });
 
-// UI가 준비된 후 비동기 초기화 이벤트 발생 (Promise가 이미 완료된 경우에도 처리됨)
-// 첫 번째 catch에서 null을 반환하므로 항상 resolved 상태로 then이 실행됨
+// 백그라운드 초기화 완료 시 UI에 이벤트 발생
+// Promise가 이미 완료된 경우에도 then이 실행되어 UI가 업데이트됨
+// catch에서 null을 반환하므로 항상 resolved 상태로 then이 실행됨
+
+// 버전 체크 완료 이벤트
 versionCheckPromise.then(info => {
     uiEvents.emit('version:update', { updateInfo: info });
 });
 
+// MCP 초기화 완료 이벤트
+// 이 시점에서 MCP 서버들과의 연결이 완료되고 도구 목록이 준비됨
 mcpInitPromise.then(integration => {
     uiEvents.emit('mcp:initialized', { integration });
 });
@@ -515,7 +620,10 @@ process.on('SIGINT', handleExit);
 // UI가 종료될 때까지 대기
 await uiInstance.waitUntilExit();
 
-// MCP Integration 정리
+// ========================================
+// 프로그램 종료 시 MCP 정리
+// ========================================
+// 모든 MCP 서버와의 연결을 정상적으로 종료하고 리소스 정리
 if (mcpIntegration) {
     await mcpIntegration.cleanup();
 }

package/mcp-agent-lib/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(mkdir:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/mcp-agent-lib/example/01-basic-usage.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+/**
+ * 기본 사용 예제 - MCP Agent Client 시작하기
+ *
+ * 이 예제는 MCP Agent Client의 가장 기본적인 사용 방법을 보여줍니다.
+ * - 클라이언트 생성
+ * - 서버 연결
+ * - 도구 목록 조회
+ * - 도구 실행
+ */
+
+import { MCPAgentClient } from '../index.js';
+
+async function main() {
+  // 1. 클라이언트 인스턴스 생성
+  // logLevel을 'info'로 설정하여 진행 상황을 확인할 수 있습니다
+  const client = new MCPAgentClient({
+    logLevel: 'info',
+    enableConsoleDebug: true
+  });
+
+  try {
+    // 2. 서버 설정으로 초기화
+    // mcpServers 객체에 연결할 서버들을 정의합니다
+    await client.initialize({
+      mcpServers: {
+        // stdio 방식 서버 예시
+        'example-server': {
+          type: 'stdio',
+          command: 'node',
+          args: ['path/to/your/server.js'],
+          // 선택사항: 환경변수 설정
+          env: {
+            NODE_ENV: 'development'
+          }
+        }
+      }
+    });
+
+    console.log('✅ 클라이언트가 성공적으로 초기화되었습니다!');
+
+    // 3. 사용 가능한 도구 목록 조회
+    const tools = client.getAvailableTools();
+    console.log('\n📋 사용 가능한 도구 목록:');
+    tools.forEach(tool => {
+      console.log(`  - ${tool.name}: ${tool.description}`);
+      console.log(`    서버: ${tool.server}`);
+    });
+
+    // 4. 특정 도구 실행하기
+    if (tools.length > 0) {
+      const firstTool = tools[0];
+      console.log(`\n🔧 도구 실행 예시: ${firstTool.name}`);
+
+      // executeTool()은 도구 이름만으로 자동으로 서버를 찾아 실행합니다
+      const result = await client.executeTool(firstTool.name, {
+        // 여기에 도구에 필요한 인자를 전달합니다
+        // 예: { query: 'test', limit: 10 }
+      });
+
+      console.log('✅ 실행 결과:', result);
+    }
+
+    // 5. 클라이언트 상태 확인
+    const status = client.getStatus();
+    console.log('\n📊 클라이언트 상태:');
+    console.log(`  - 초기화 완료: ${status.initialized}`);
+    console.log(`  - 연결된 서버 수: ${status.connectedServers}/${status.totalServers}`);
+    console.log(`  - 사용 가능한 도구 수: ${status.totalTools}`);
+
+  } catch (error) {
+    console.error('❌ 오류 발생:', error.message);
+  } finally {
+    // 6. 리소스 정리 및 연결 해제
+    await client.disconnect();
+    console.log('\n👋 클라이언트 연결이 해제되었습니다.');
+  }
+}
+
+// 실행
+main().catch(console.error);

package/mcp-agent-lib/example/02-quick-start.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+/**
+ * 빠른 시작 예제 - quickStart() 함수 사용
+ *
+ * quickStart() 함수를 사용하면 클라이언트 생성과 초기화를
+ * 한 번에 수행할 수 있어 가장 간단하게 시작할 수 있습니다.
+ */
+
+import { quickStart } from '../index.js';
+
+async function main() {
+  // quickStart()는 클라이언트 생성 + 초기화를 한 번에 수행합니다
+  const client = await quickStart(
+    // 첫 번째 인자: 서버 설정
+    {
+      mcpServers: {
+        'my-server': {
+          type: 'stdio',
+          command: 'node',
+          args: ['server.js']
+        }
+      }
+    },
+    // 두 번째 인자: 클라이언트 옵션 (선택사항)
+    {
+      logLevel: 'info',
+      enableConsoleDebug: true,
+      timeout: 30000,      // 30초 타임아웃
+      retries: 3           // 실패 시 3회 재시도
+    }
+  );
+
+  try {
+    console.log('✅ 클라이언트 준비 완료!');
+
+    // 바로 도구를 사용할 수 있습니다
+    const tools = client.getAvailableTools();
+    console.log(`📋 ${tools.length}개의 도구를 사용할 수 있습니다.`);
+
+    // 도구 실행
+    if (tools.length > 0) {
+      const result = await client.executeTool(tools[0].name);
+      console.log('결과:', result);
+    }
+
+  } finally {
+    await client.disconnect();
+  }
+}
+
+main().catch(console.error);

package/mcp-agent-lib/example/03-http-server.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+/**
+ * HTTP 서버 연결 예제
+ *
+ * stdio 방식 대신 HTTP/HTTPS를 통해 원격 MCP 서버에 연결하는 방법입니다.
+ * 인증이 필요한 경우 Bearer 토큰을 헤더에 포함시킬 수 있습니다.
+ */
+
+import { MCPAgentClient } from '../index.js';
+
+async function main() {
+  const client = new MCPAgentClient({
+    logLevel: 'info',
+    enableConsoleDebug: true
+  });
+
+  try {
+    await client.initialize({
+      mcpServers: {
+        // HTTP 방식 서버 (인증 없음)
+        'public-api': {
+          type: 'http',
+          url: 'https://api.example.com/mcp'
+        },
+
+        // HTTP 방식 서버 (Bearer 토큰 인증)
+        'secured-api': {
+          type: 'http',
+          url: 'https://secure-api.example.com/mcp',
+          headers: {
+            'Authorization': 'Bearer YOUR_TOKEN_HERE',
+            'X-API-Key': 'your-api-key'
+          }
+        },
+
+        // 로컬 HTTP 서버
+        'local-http': {
+          type: 'http',
+          url: 'http://localhost:3000/mcp'
+        }
+      }
+    });
+
+    console.log('✅ HTTP 서버들에 연결되었습니다.');
+
+    // 연결된 서버별 상태 확인
+    const status = client.getStatus();
+    console.log('\n📊 서버별 상태:');
+    for (const [serverName, serverStatus] of Object.entries(status.servers)) {
+      console.log(`\n${serverName}:`);
+      console.log(`  - 상태: ${serverStatus.status}`);
+      console.log(`  - 타입: ${serverStatus.type}`);
+      console.log(`  - 도구 수: ${serverStatus.toolCount}`);
+    }
+
+    // 특정 서버의 도구만 조회
+    const publicTools = client.getServerTools('public-api');
+    console.log('\n🔧 public-api의 도구:');
+    publicTools.forEach(tool => {
+      console.log(`  - ${tool.name}: ${tool.description}`);
+    });
+
+  } catch (error) {
+    console.error('❌ 오류:', error.message);
+
+    // HTTP 인증 실패 시 자세한 정보가 로그에 출력됩니다
+    if (error.message.includes('401')) {
+      console.error('💡 인증 토큰을 확인해주세요.');
+    }
+  } finally {
+    await client.disconnect();
+  }
+}
+
+main().catch(console.error);

package/mcp-agent-lib/example/04-multiple-servers.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+/**
+ * 다중 서버 연결 예제
+ *
+ * 여러 MCP 서버에 동시에 연결하여 사용하는 방법입니다.
+ * 각 서버는 서로 다른 전송 방식(stdio, HTTP, SSE)을 사용할 수 있습니다.
+ */
+
+import { MCPAgentClient } from '../index.js';
+
+async function main() {
+  const client = new MCPAgentClient({
+    logLevel: 'info',
+    enableConsoleDebug: true
+  });
+
+  try {
+    // 여러 서버에 동시 연결
+    await client.initialize({
+      mcpServers: {
+        // 파일 시스템 도구를 제공하는 서버
+        'filesystem': {
+          type: 'stdio',
+          command: 'node',
+          args: ['servers/filesystem-server.js']
+        },
+
+        // 데이터베이스 도구를 제공하는 서버
+        'database': {
+          type: 'stdio',
+          command: 'python',
+          args: ['-m', 'mcp_server_db']
+        },
+
+        // 원격 API 서버
+        'remote-api': {
+          type: 'http',
+          url: 'https://api.example.com/mcp',
+          headers: {
+            'Authorization': 'Bearer TOKEN'
+          }
+        },
+
+        // 실시간 이벤트 서버
+        'event-stream': {
+          type: 'sse',
+          url: 'https://events.example.com/mcp'
+        }
+      }
+    });
+
+    console.log('✅ 모든 서버에 연결되었습니다.');
+
+    // 1. 전체 도구 목록 조회 (모든 서버의 도구)
+    const allTools = client.getAvailableTools();
+    console.log(`\n📋 총 ${allTools.length}개의 도구 사용 가능:`);
+
+    // 서버별로 그룹화하여 출력
+    const toolsByServer = {};
+    allTools.forEach(tool => {
+      if (!toolsByServer[tool.server]) {
+        toolsByServer[tool.server] = [];
+      }
+      toolsByServer[tool.server].push(tool);
+    });
+
+    for (const [serverName, tools] of Object.entries(toolsByServer)) {
+      console.log(`\n${serverName} (${tools.length}개):`);
+      tools.forEach(tool => {
+        console.log(`  - ${tool.name}: ${tool.description}`);
+      });
+    }
+
+    // 2. 특정 서버의 도구만 사용
+    console.log('\n🔧 filesystem 서버의 도구 실행:');
+    const fsTools = client.getServerTools('filesystem');
+    if (fsTools.length > 0) {
+      // callTool()을 사용하여 특정 서버의 도구를 직접 호출
+      const result = await client.callTool('filesystem', fsTools[0].name, {
+        path: '/tmp'
+      });
+      console.log('결과:', result);
+    }
+
+    // 3. 도구 이름만으로 자동 실행 (어느 서버의 도구인지 자동 검색)
+    console.log('\n🔍 자동 서버 검색으로 도구 실행:');
+    if (allTools.length > 0) {
+      // executeTool()은 도구 이름만으로 자동으로 서버를 찾습니다
+      const result = await client.executeTool(allTools[0].name);
+      console.log(`${allTools[0].name} (서버: ${result.server}):`, result.data);
+    }
+
+    // 4. 리소스 목록 조회 (모든 서버)
+    const resources = await client.listAllResources();
+    console.log(`\n📄 사용 가능한 리소스: ${resources.length}개`);
+    resources.forEach(resource => {
+      console.log(`  - ${resource.name} (${resource.serverName})`);
+      console.log(`    URI: ${resource.uri}`);
+    });
+
+    // 5. 프롬프트 목록 조회 (모든 서버)
+    const prompts = await client.listAllPrompts();
+    console.log(`\n💬 사용 가능한 프롬프트: ${prompts.length}개`);
+    prompts.forEach(prompt => {
+      console.log(`  - ${prompt.name} (${prompt.serverName})`);
+      console.log(`    ${prompt.description}`);
+    });
+
+  } catch (error) {
+    console.error('❌ 오류:', error.message);
+  } finally {
+    await client.disconnect();
+  }
+}
+
+main().catch(console.error);

package/mcp-agent-lib/example/05-error-handling.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+/**
+ * 에러 처리 및 재시도 예제
+ *
+ * MCP 클라이언트의 강력한 에러 처리와 자동 재시도 기능을 보여줍니다.
+ * - 자동 재시도 설정
+ * - 타임아웃 처리
+ * - 서버 연결 끊김 감지
+ * - 이벤트 기반 에러 모니터링
+ */
+
+import { MCPAgentClient } from '../index.js';
+
+async function main() {
+  const client = new MCPAgentClient({
+    logLevel: 'info',
+    enableConsoleDebug: true,
+
+    // 재시도 설정
+    timeout: 10000,        // 10초 타임아웃
+    retries: 5,            // 최대 5회 재시도
+    retryDelay: 1000,      // 첫 재시도는 1초 후
+    maxRetryDelay: 30000   // 최대 30초까지 지연
+  });
+
+  // 1. 서버 에러 이벤트 리스너
+  client.on('serverError', (serverName, error) => {
+    console.error(`⚠️ 서버 에러 [${serverName}]:`, error.message);
+  });
+
+  // 2. 서버 연결 해제 이벤트 리스너
+  client.on('serverDisconnected', (serverName) => {
+    console.warn(`🔌 서버 연결 끊김: ${serverName}`);
+  });
+
+  // 3. 서버 상태 변경 이벤트 리스너
+  client.on('serverStatusChange', ({ serverName, status, previousStatus }) => {
+    console.log(`📡 ${serverName}: ${previousStatus} → ${status}`);
+  });
+
+  try {
+    await client.initialize({
+      mcpServers: {
+        'test-server': {
+          type: 'stdio',
+          command: 'node',
+          args: ['server.js']
+        }
+      }
+    });
+
+    // 예제 1: 기본 재시도 (클라이언트 설정 사용)
+    try {
+      console.log('\n🔧 도구 실행 (자동 재시도 활성화)...');
+      const result = await client.executeTool('some-tool', {
+        param: 'value'
+      });
+      console.log('✅ 성공:', result);
+    } catch (error) {
+      console.error('❌ 모든 재시도 실패:', error.message);
+    }
+
+    // 예제 2: 커스텀 재시도 설정
+    try {
+      console.log('\n🔧 도구 실행 (커스텀 타임아웃/재시도)...');
+      const result = await client.executeTool(
+        'slow-tool',
+        { query: 'test' },
+        {
+          timeout: 5000,   // 이 호출만 5초 타임아웃
+          retries: 2       // 이 호출만 2회 재시도
+        }
+      );
+      console.log('✅ 성공:', result);
+    } catch (error) {
+      console.error('❌ 실패:', error.message);
+    }
+
+    // 예제 3: 서버 상태 확인 후 실행
+    const status = client.getStatus();
+    console.log('\n📊 현재 서버 상태:');
+    for (const [serverName, serverStatus] of Object.entries(status.servers)) {
+      console.log(`${serverName}: ${serverStatus.status}`);
+
+      if (serverStatus.status === 'connected') {
+        console.log(`  ✅ 연결됨 - ${serverStatus.toolCount}개 도구 사용 가능`);
+      } else if (serverStatus.status === 'partially_connected') {
+        console.log(`  ⚠️ 부분 연결 - 일부 기능만 사용 가능`);
+      } else {
+        console.log(`  ❌ 연결 안됨 - 사용 불가`);
+      }
+    }
+
+    // 예제 4: 특정 서버 연결 해제 및 재연결 처리
+    console.log('\n🔌 test-server 연결 해제...');
+    await client.disconnectServer('test-server');
+
+    const updatedStatus = client.getStatus();
+    console.log(`연결된 서버: ${updatedStatus.connectedServers}/${updatedStatus.totalServers}`);
+
+  } catch (error) {
+    // 초기화 실패 처리
+    if (error.message.includes('not allowed')) {
+      console.error('❌ 보안 에러: 허용되지 않은 명령어 또는 인자');
+    } else if (error.message.includes('timeout')) {
+      console.error('❌ 타임아웃: 서버 응답 없음');
+    } else {
+      console.error('❌ 예상치 못한 에러:', error.message);
+    }
+  } finally {
+    await client.disconnect();
+  }
+}
+
+main().catch(console.error);