companionbot 0.6.0 → 0.7.0

package/dist/health/index.js

@@ -0,0 +1,66 @@
+/**
+ * 봇 헬스 체크 모듈
+ * 봇의 상태를 추적하고 모니터링합니다.
+ * @module health
+ */
+let startTime = Date.now();
+let lastActivity = Date.now();
+let messageCount = 0;
+let errorCount = 0;
+/**
+ * 활동을 기록합니다.
+ * 메시지 처리 시 호출하여 마지막 활동 시간과 메시지 카운트를 업데이트합니다.
+ */
+export function recordActivity() {
+    lastActivity = Date.now();
+    messageCount++;
+}
+/**
+ * 오류 발생을 기록합니다.
+ */
+export function recordError() {
+    errorCount++;
+}
+/**
+ * 현재 봇의 건강 상태를 조회합니다.
+ * @returns 건강 상태 정보
+ */
+export function getHealthStatus() {
+    const now = Date.now();
+    const uptime = Math.floor((now - startTime) / 1000);
+    const inactiveTime = now - lastActivity;
+    // 30분 이상 활동 없으면 unhealthy
+    const isHealthy = inactiveTime < 30 * 60 * 1000;
+    return {
+        uptime,
+        lastActivity,
+        messageCount,
+        errorCount,
+        isHealthy
+    };
+}
+/**
+ * 가동 시간을 읽기 좋은 형태로 포맷합니다.
+ * @param seconds - 가동 시간 (초)
+ * @returns 포맷된 문자열 (예: "2일 3시간", "5시간 30분")
+ */
+export function formatUptime(seconds) {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const mins = Math.floor((seconds % 3600) / 60);
+    if (days > 0)
+        return `${days}일 ${hours}시간`;
+    if (hours > 0)
+        return `${hours}시간 ${mins}분`;
+    return `${mins}분`;
+}
+/**
+ * 헬스 상태를 초기화합니다.
+ * 테스트나 재시작 시 사용합니다.
+ */
+export function resetHealth() {
+    startTime = Date.now();
+    lastActivity = Date.now();
+    messageCount = 0;
+    errorCount = 0;
+}

package/dist/heartbeat/index.js

@@ -4,15 +4,21 @@ import { getWorkspacePath } from "../workspace/index.js";
 import { chat } from "../ai/claude.js";
 import { isCalendarConfigured, getTodayEvents, formatEvent } from "../calendar/index.js";
 import { getSecret } from "../config/secrets.js";
+import { checkForUpdates } from "../updates/index.js";
+import { INTERVAL_30_MINUTES, INTERVAL_24_HOURS, hoursToMs } from "../utils/time.js";
 // 활성 타이머
 const activeTimers = new Map();
 // 메모리 캐시: 타임스탬프는 메모리에만 유지하여 파일 쓰기 최소화
 // lastCheckAt, lastMessageAt은 디버깅 용도라 매번 저장할 필요 없음
 const timestampCache = new Map();
+// 업데이트 체크 캐시 (하루에 한 번만)
+let lastUpdateCheck = 0;
+let cachedUpdateInfo = null;
+const UPDATE_CHECK_INTERVAL = INTERVAL_24_HOURS;
 // 봇 인스턴스
 let botInstance = null;
 // 기본 간격: 30분
-const DEFAULT_INTERVAL_MS = 30 * 60 * 1000;
+const DEFAULT_INTERVAL_MS = INTERVAL_30_MINUTES;
 export function setHeartbeatBot(bot) {
     botInstance = bot;
 }
@@ -79,6 +85,21 @@ async function gatherContext() {
             // 무시
         }
     }
+    // 업데이트 체크 (하루에 한 번)
+    const timeSinceLastCheck = Date.now() - lastUpdateCheck;
+    if (timeSinceLastCheck > UPDATE_CHECK_INTERVAL) {
+        try {
+            cachedUpdateInfo = await checkForUpdates();
+            lastUpdateCheck = Date.now();
+            console.log(`[Heartbeat] Update check: current=${cachedUpdateInfo.current}, latest=${cachedUpdateInfo.latest}`);
+        }
+        catch (error) {
+            console.error("[Heartbeat] Update check failed:", error);
+        }
+    }
+    if (cachedUpdateInfo?.hasUpdate) {
+        parts.push(`🆕 업데이트 알림: CompanionBot ${cachedUpdateInfo.latest} 버전이 출시됨! (현재: ${cachedUpdateInfo.current})`);
+    }
     return parts.join("\n");
 }
 // Heartbeat 실행 - 메시지를 보냈으면 true 반환
@@ -257,7 +278,7 @@ export async function runHeartbeatNow(chatId) {
             enabled: false,
             intervalMs: DEFAULT_INTERVAL_MS,
             lastCheckAt: Date.now(),
-            lastMessageAt: Date.now() - (8 * 60 * 60 * 1000), // 8시간 전으로 설정
+            lastMessageAt: Date.now() - hoursToMs(8), // 8시간 전으로 설정
         };
         return await executeHeartbeat(defaultConfig);
     }

package/dist/memory/embeddings.js

@@ -37,6 +37,10 @@ async function getEmbeddingPipeline() {
  * @returns 384차원 임베딩 벡터
  */
 export async function embed(text) {
+    // null/undefined 처리
+    if (text == null) {
+        return new Array(384).fill(0);
+    }
     const pipe = await getEmbeddingPipeline();
     // 텍스트 정규화
     const cleanText = text.trim().slice(0, 512); // 최대 512자
@@ -52,13 +56,25 @@ export async function embed(text) {
 }
 /**
  * 여러 텍스트를 배치로 임베딩합니다.
+ * 병렬로 처리하여 성능 향상 (모델 내부에서 순차 처리되더라도 Promise 오버헤드 감소)
  * @param texts 변환할 텍스트 배열
  * @returns 임베딩 벡터 배열
  */
 export async function embedBatch(texts) {
-    const results = [];
-    for (const text of texts) {
-        results.push(await embed(text));
+    // null/undefined 배열 처리
+    if (!texts || texts.length === 0)
+        return [];
+    if (texts.length === 1)
+        return [await embed(texts[0])];
+    // 동시성 제한 (메모리 보호)
+    const CONCURRENCY = 5;
+    const results = new Array(texts.length);
+    for (let i = 0; i < texts.length; i += CONCURRENCY) {
+        const batch = texts.slice(i, i + CONCURRENCY);
+        const batchResults = await Promise.all(batch.map(text => embed(text)));
+        for (let j = 0; j < batchResults.length; j++) {
+            results[i + j] = batchResults[j];
+        }
     }
     return results;
 }
@@ -70,6 +86,9 @@ export async function embedBatch(texts) {
  * normalized 파라미터가 true면 내적만 계산하여 성능 향상.
  */
 export function cosineSimilarity(a, b, normalized = true) {
+    // null/undefined 또는 빈 배열 처리
+    if (!a || !b || a.length === 0 || b.length === 0)
+        return 0;
     if (a.length !== b.length)
         return 0;
     let dotProduct = 0;

package/dist/memory/vectorStore.js

@@ -5,7 +5,7 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { getMemoryDirPath, getWorkspaceFilePath } from "../workspace/paths.js";
-import { embed, cosineSimilarity } from "./embeddings.js";
+import { embed, embedBatch, cosineSimilarity } from "./embeddings.js";
 // 캐시된 청크들 (임베딩 포함)
 let cachedChunks = [];
 let cacheTimestamp = 0;
@@ -103,10 +103,16 @@ export async function loadAllMemoryChunks() {
     try {
         const chunks = await loadingPromise;
         // 캐시 업데이트 (임베딩은 아직 없음)
+        // 빈 결과도 캐시하되 TTL을 짧게 (1분)
         cachedChunks = chunks;
-        cacheTimestamp = Date.now();
+        cacheTimestamp = chunks.length > 0 ? Date.now() : Date.now() - CACHE_TTL_MS + 60000;
         return chunks;
     }
+    catch (error) {
+        // 로드 실패 시 캐시하지 않음
+        console.error("[VectorStore] Failed to load memory chunks:", error);
+        return [];
+    }
     finally {
         loadingPromise = null;
     }
@@ -122,25 +128,41 @@ export async function search(queryEmbedding, topK = 5, minScore = 0.3) {
     if (chunks.length === 0) {
         return [];
     }
-    // 각 청크에 대해 임베딩 생성 및 유사도 계산
-    const results = [];
-    for (const chunk of chunks) {
+    // 임베딩이 없는 청크들을 배치로 처리
+    const chunksNeedingEmbedding = chunks.filter(c => !c.embedding);
+    if (chunksNeedingEmbedding.length > 0) {
         try {
-            // 캐시된 임베딩이 없으면 생성
-            if (!chunk.embedding) {
-                chunk.embedding = await embed(chunk.text);
-            }
-            const score = cosineSimilarity(queryEmbedding, chunk.embedding);
-            if (score >= minScore) {
-                results.push({
-                    text: chunk.text,
-                    source: chunk.source,
-                    score,
-                });
+            const texts = chunksNeedingEmbedding.map(c => c.text);
+            const embeddings = await embedBatch(texts);
+            // 임베딩 할당
+            for (let i = 0; i < chunksNeedingEmbedding.length; i++) {
+                chunksNeedingEmbedding[i].embedding = embeddings[i];
             }
         }
         catch {
-            // 임베딩 실패 무시
+            // 배치 실패 시 개별 처리 폴백
+            for (const chunk of chunksNeedingEmbedding) {
+                try {
+                    chunk.embedding = await embed(chunk.text);
+                }
+                catch {
+                    // 개별 실패 무시
+                }
+            }
+        }
+    }
+    // 유사도 계산 및 필터링
+    const results = [];
+    for (const chunk of chunks) {
+        if (!chunk.embedding)
+            continue;
+        const score = cosineSimilarity(queryEmbedding, chunk.embedding);
+        if (score >= minScore) {
+            results.push({
+                text: chunk.text,
+                source: chunk.source,
+                score,
+            });
         }
     }
     // 유사도 점수로 정렬하고 상위 K개 반환

package/dist/session/state.js

@@ -9,6 +9,16 @@ const sessions = new Map();
 // AsyncLocalStorage for chatId context
 const chatIdStorage = new AsyncLocalStorage();
 function getSession(chatId) {
+    // chatId 유효성 검사
+    if (chatId == null || isNaN(chatId)) {
+        console.warn(`[Session] Invalid chatId: ${chatId}, using fallback session`);
+        // 임시 세션 반환 (저장하지 않음)
+        return {
+            history: [],
+            model: "sonnet",
+            lastAccessedAt: Date.now(),
+        };
+    }
     const existing = sessions.get(chatId);
     const now = Date.now();
     if (existing) {
@@ -44,13 +54,20 @@ function cleanupSessions() {
     }
 }
 export function getHistory(chatId) {
-    return getSession(chatId).history;
+    const session = getSession(chatId);
+    // 참조 반환 (외부 수정 허용 - 의도적)
+    // 필요시 [...session.history]로 복사본 반환 가능
+    return session.history ?? [];
 }
 /**
  * 히스토리를 토큰 기반으로 트리밍한다.
  * 최대 토큰 한도를 초과하면 가장 오래된 메시지부터 제거 (최소 2개는 유지).
  */
 export function trimHistoryByTokens(history) {
+    // null/undefined/빈 배열 처리
+    if (!history || history.length === 0) {
+        return;
+    }
     while (estimateMessagesTokens(history) > MAX_HISTORY_TOKENS && history.length > 2) {
         history.shift();
     }

package/dist/telegram/handlers/commands.js

@@ -1,4 +1,5 @@
 import { randomBytes } from "crypto";
+import { getHealthStatus, formatUptime } from "../../health/index.js";
 import { chat, MODELS } from "../../ai/claude.js";
 import { estimateMessagesTokens } from "../../utils/tokens.js";
 // 대화 요약 생성 함수
@@ -458,8 +459,12 @@ export function registerCommands(bot) {
                             await ctx.reply("❌ 인증 실패. 다시 시도해주세요.");
                         }
                     })
-                        .catch(() => {
-                        // 타임아웃 등
+                        .catch(async (error) => {
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        console.error(`[Calendar] Auth server error for chatId=${ctx.chat.id}:`, errorMsg);
+                        if (errorMsg.includes("timeout") || errorMsg.includes("Timeout")) {
+                            await ctx.reply("⏰ 인증 시간이 만료됐어요. /calendar_setup 으로 다시 시도해주세요.");
+                        }
                     });
                 }
                 return;
@@ -512,8 +517,12 @@ export function registerCommands(bot) {
                         await ctx.reply("❌ 인증 실패. 다시 시도해주세요.");
                     }
                 })
-                    .catch(() => {
-                    // 타임아웃
+                    .catch(async (error) => {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    console.error("[Calendar] Auth server error:", errorMsg);
+                    if (errorMsg.includes("timeout") || errorMsg.includes("Timeout")) {
+                        await ctx.reply("⏰ 인증 시간이 만료됐어요. /calendar_setup 으로 다시 시도해주세요.");
+                    }
                 });
             }
             return;
@@ -540,8 +549,17 @@ export function registerCommands(bot) {
             await ctx.reply(message);
         }
         catch (error) {
-            console.error("Calendar error:", error);
-            await ctx.reply("캘린더 조회 중 오류가 발생했어요.");
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.error(`[Calendar] chatId=${ctx.chat.id} getTodayEvents error:`, errorMsg);
+            if (errorMsg.includes("invalid_grant") || errorMsg.includes("Token")) {
+                await ctx.reply("캘린더 인증이 만료됐어요. /calendar_setup 으로 다시 연동해주세요.");
+            }
+            else if (errorMsg.includes("timeout") || errorMsg.includes("ETIMEDOUT")) {
+                await ctx.reply("Google 서버 응답이 느려요. 잠시 후 다시 시도해주세요.");
+            }
+            else {
+                await ctx.reply("캘린더를 불러오지 못했어요. 잠시 후 다시 시도해주세요.");
+            }
         }
     });
     // /briefing 명령어 - 토글 방식
@@ -582,4 +600,13 @@ export function registerCommands(bot) {
                 `"10분마다 체크해줘"로 간격 변경 가능`);
         }
     });
+    // /health 명령어 - 봇 상태 확인
+    bot.command("health", async (ctx) => {
+        const status = getHealthStatus();
+        await ctx.reply(`🏥 봇 상태\n\n` +
+            `⏱ 가동: ${formatUptime(status.uptime)}\n` +
+            `💬 메시지: ${status.messageCount}개\n` +
+            `❌ 에러: ${status.errorCount}개\n` +
+            `🔋 상태: ${status.isHealthy ? "정상 ✅" : "점검 필요 ⚠️"}`);
+    });
 }

package/dist/telegram/handlers/messages.js

@@ -1,7 +1,43 @@
 import { chat, chatSmart } from "../../ai/claude.js";
+import { recordActivity, recordError } from "../../health/index.js";
 import { getHistory, getModel, runWithChatId, trimHistoryByTokens, } from "../../session/state.js";
 import { updateLastMessageTime } from "../../heartbeat/index.js";
 import { extractUrls, fetchWebContent, buildSystemPrompt, } from "../utils/index.js";
+import { estimateMessagesTokens } from "../../utils/tokens.js";
+const MAX_CONTEXT_TOKENS = 100000; // Claude 컨텍스트
+const COMPACTION_THRESHOLD = 0.6; // 60%
+/**
+ * 토큰 사용량이 임계치를 넘으면 자동으로 히스토리 압축
+ * 실패해도 메시지 처리에 영향 없도록 에러를 조용히 처리
+ */
+async function autoCompactIfNeeded(ctx, history) {
+    try {
+        const tokens = estimateMessagesTokens(history);
+        const usage = tokens / MAX_CONTEXT_TOKENS;
+        if (usage > COMPACTION_THRESHOLD && history.length > 6) {
+            // 자동 compaction 실행
+            console.log(`[AutoCompact] chatId=${ctx.chat?.id} usage=${(usage * 100).toFixed(1)}% - compacting...`);
+            // 앞부분 요약 생성 (최근 4개 메시지 제외)
+            const oldMessages = history.slice(0, -4);
+            const summaryPrompt = "다음 대화를 3-4문장으로 요약해줘:\n\n" +
+                oldMessages
+                    .map((m) => `${m.role}: ${typeof m.content === "string" ? m.content : "[media]"}`)
+                    .join("\n");
+            const summary = await chat([{ role: "user", content: summaryPrompt }], "", "haiku");
+            // 히스토리 교체
+            const recentMessages = history.slice(-4);
+            history.splice(0, history.length);
+            history.push({ role: "user", content: `[이전 대화 요약]\n${summary}` });
+            history.push(...recentMessages);
+            const newTokens = estimateMessagesTokens(history);
+            await ctx.reply(`📦 자동 정리: ${tokens} → ${newTokens} 토큰`);
+        }
+    }
+    catch (error) {
+        // 자동 압축 실패는 치명적이지 않음 - 로깅만 하고 계속 진행
+        console.warn(`[AutoCompact] Failed for chatId=${ctx.chat?.id}:`, error instanceof Error ? error.message : error);
+    }
+}
 /**
  * 스트리밍 응답 전송 (Telegram 메시지 실시간 업데이트)
  */
@@ -57,6 +93,7 @@ export function registerMessageHandlers(bot) {
     bot.on("message:photo", async (ctx) => {
         const chatId = ctx.chat.id;
         await runWithChatId(chatId, async () => {
+            recordActivity();
             const history = getHistory(chatId);
             const modelId = getModel(chatId);
             await ctx.replyWithChatAction("typing");
@@ -112,8 +149,19 @@ export function registerMessageHandlers(bot) {
                 }
             }
             catch (error) {
-                console.error("Photo error:", error);
-                await ctx.reply("사진 분석 중 오류가 발생했어.");
+                recordError();
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.error(`[Photo] chatId=${chatId} error:`, errorMsg);
+                // 사용자 친화적 에러 메시지
+                if (errorMsg.includes("rate limit") || errorMsg.includes("429")) {
+                    await ctx.reply("지금 요청이 많아서 사진을 분석할 수 없어. 잠시 후 다시 보내줄래?");
+                }
+                else if (errorMsg.includes("timeout")) {
+                    await ctx.reply("사진 분석이 너무 오래 걸렸어. 다시 보내줄래?");
+                }
+                else {
+                    await ctx.reply("사진을 분석하다가 문제가 생겼어. 다시 보내줄래?");
+                }
             }
         });
     });
@@ -125,6 +173,8 @@ export function registerMessageHandlers(bot) {
         if (!userMessage.trim())
             return;
         await runWithChatId(chatId, async () => {
+            // Health 추적: 활동 기록
+            recordActivity();
             // Heartbeat 마지막 대화 시간 업데이트
             updateLastMessageTime(chatId);
             const history = getHistory(chatId);
@@ -156,12 +206,29 @@ export function registerMessageHandlers(bot) {
                 history.push({ role: "assistant", content: response });
                 // 토큰 기반 히스토리 트리밍
                 trimHistoryByTokens(history);
+                // 자동 compaction 체크
+                await autoCompactIfNeeded(ctx, history);
             }
             catch (error) {
                 // 에러 시 방금 추가한 사용자 메시지 롤백 (히스토리 오염 방지)
                 history.pop();
-                console.error("Chat error:", error);
-                await ctx.reply("뭔가 잘못됐어. 다시 시도해줄래?");
+                recordError();
+                // 구체적인 에러 로깅
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.error(`[Chat] chatId=${chatId} error:`, errorMsg);
+                // 사용자 친화적 에러 메시지
+                if (errorMsg.includes("rate limit") || errorMsg.includes("429")) {
+                    await ctx.reply("지금 요청이 많아서 잠깐 쉬어야 해. 30초 후에 다시 시도해줄래?");
+                }
+                else if (errorMsg.includes("timeout") || errorMsg.includes("ETIMEDOUT")) {
+                    await ctx.reply("응답이 너무 오래 걸려서 중단됐어. 다시 시도해줄래?");
+                }
+                else if (errorMsg.includes("context") || errorMsg.includes("token")) {
+                    await ctx.reply("대화가 너무 길어졌어. /compact 로 정리하고 다시 시도해줘!");
+                }
+                else {
+                    await ctx.reply("메시지 처리 중 문제가 생겼어. 다시 시도해줄래?");
+                }
             }
         });
     });

package/dist/telegram/utils/url.js

@@ -8,6 +8,13 @@ export function extractUrls(text) {
 }
 /**
  * URL 안전성 검사 (SSRF 방지)
+ *
+ * 차단 대상:
+ * - 모든 사설 IPv4 (10.x, 172.16-31.x, 192.168.x, 127.x, 0.x, 169.254.x)
+ * - 모든 사설/특수 IPv6 (::1, fe80::, fd00::/8, fc00::/7)
+ * - IPv4-mapped IPv6 (::ffff:127.0.0.1 등)
+ * - 클라우드 메타데이터 엔드포인트
+ * - .local, .internal 도메인
  */
 export function isSafeUrl(url) {
     try {
@@ -17,20 +24,44 @@ export function isSafeUrl(url) {
             return false;
         }
         const hostname = parsed.hostname.toLowerCase();
-        // 로컬/내부 네트워크 차단
+        // localhost 및 특수 도메인 차단
         if (hostname === "localhost" ||
-            hostname === "127.0.0.1" ||
-            hostname === "0.0.0.0" ||
-            hostname.startsWith("192.168.") ||
-            hostname.startsWith("10.") ||
+            hostname === "localhost.localdomain" ||
             hostname.endsWith(".local") ||
             hostname.endsWith(".internal") ||
-            hostname === "169.254.169.254" || // AWS/Cloud metadata
+            hostname.endsWith(".localhost")) {
+            return false;
+        }
+        // 클라우드 메타데이터 엔드포인트 차단
+        if (hostname === "169.254.169.254" || // AWS/GCP/Azure metadata
+            hostname === "metadata.google.internal" ||
             (hostname.endsWith(".amazonaws.com") && hostname.includes("metadata"))) {
             return false;
         }
-        // 172.16.0.0/12 (172.16.x.x ~ 172.31.x.x) 정확히 차단
-        if (/^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(hostname)) {
+        // IPv4 사설 주소 차단
+        const ipv4PrivatePatterns = [
+            /^127\./, // 127.0.0.0/8 loopback
+            /^10\./, // 10.0.0.0/8
+            /^172\.(1[6-9]|2[0-9]|3[0-1])\./, // 172.16.0.0/12
+            /^192\.168\./, // 192.168.0.0/16
+            /^0\./, // 0.0.0.0/8
+            /^169\.254\./, // link-local
+        ];
+        if (ipv4PrivatePatterns.some((p) => p.test(hostname))) {
+            return false;
+        }
+        // IPv6 사설/특수 주소 차단 (브라켓 제거 후 검사)
+        const ipv6Host = hostname.replace(/^\[|\]$/g, "");
+        const ipv6PrivatePatterns = [
+            /^::1$/, // loopback
+            /^fe80:/i, // link-local
+            /^fd[0-9a-f]{2}:/i, // unique local (fd00::/8)
+            /^fc[0-9a-f]{2}:/i, // unique local (fc00::/7)
+            /^::$/, // unspecified
+            // IPv4-mapped IPv6 (::ffff:127.0.0.1 등)
+            /^::ffff:(127\.|10\.|172\.(1[6-9]|2[0-9]|3[0-1])\.|192\.168\.|0\.|169\.254\.)/i,
+        ];
+        if (ipv6PrivatePatterns.some((p) => p.test(ipv6Host))) {
             return false;
         }
         return true;

package/dist/tools/index.js

@@ -6,6 +6,7 @@ import { promisify } from "util";
 import { randomUUID } from "crypto";
 import { MODELS } from "../ai/claude.js";
 import { getCurrentChatId, setModel, getModel } from "../session/state.js";
+import { SESSION_MAX_OUTPUT_LINES, SESSION_CLEANUP_INTERVAL_MS, SESSION_TTL_MS, } from "../utils/constants.js";
 // Note: getCurrentChatId uses AsyncLocalStorage - must be called within runWithChatId context
 import { getWorkspacePath, saveWorkspaceFile, appendToMemory, deleteBootstrap, } from "../workspace/index.js";
 import { getSecret } from "../config/secrets.js";
@@ -22,11 +23,6 @@ import { reindexAll } from '../memory/indexer.js';
 const execAsync = promisify(exec);
 // 메모리에 세션 저장
 const sessions = new Map();
-// Output buffer 최대 크기 (라인 수)
-const MAX_OUTPUT_LINES = 1000;
-// 세션 정리 간격 및 TTL (메모리 누수 방지)
-const SESSION_CLEANUP_INTERVAL_MS = 10 * 60 * 1000; // 10분마다 정리
-const SESSION_TTL_MS = 60 * 60 * 1000; // 완료된 세션 1시간 후 삭제
 // 완료된 세션 자동 정리 함수
 function cleanupStaleSessions() {
     const now = Date.now();
@@ -46,20 +42,25 @@ function appendOutput(session, data) {
     const lines = data.split("\n");
     session.outputBuffer.push(...lines);
     // 버퍼 크기 제한
-    if (session.outputBuffer.length > MAX_OUTPUT_LINES) {
-        session.outputBuffer = session.outputBuffer.slice(-MAX_OUTPUT_LINES);
+    if (session.outputBuffer.length > SESSION_MAX_OUTPUT_LINES) {
+        session.outputBuffer = session.outputBuffer.slice(-SESSION_MAX_OUTPUT_LINES);
     }
 }
 // 홈 디렉토리
 const home = process.env.HOME || "";
-// 허용된 디렉토리 설정
+// 허용된 디렉토리 설정 (캐시됨 - 환경변수는 런타임 중 변경되지 않음)
 // - COMPANIONBOT_FULL_ACCESS=true: 홈 디렉토리 전체 접근 (위험한 파일 패턴은 여전히 차단)
 // - COMPANIONBOT_ALLOWED_PATHS: 콜론(:)으로 구분된 추가 경로 (예: /tmp:/var/data)
 // - 기본값: ~/Documents, ~/projects, 워크스페이스
+let _cachedAllowedPaths = null;
 function getAllowedPaths() {
+    if (_cachedAllowedPaths) {
+        return _cachedAllowedPaths;
+    }
     // 전체 접근 모드
     if (process.env.COMPANIONBOT_FULL_ACCESS === "true") {
-        return [home];
+        _cachedAllowedPaths = [home];
+        return _cachedAllowedPaths;
     }
     // 기본 경로
     const paths = [
@@ -77,7 +78,8 @@ function getAllowedPaths() {
             paths.push(expanded);
         }
     }
-    return paths;
+    _cachedAllowedPaths = paths;
+    return _cachedAllowedPaths;
 }
 // 위험한 파일 패턴
 // SSRF 방지: 사설 IP 체크

package/dist/updates/index.js

@@ -0,0 +1,52 @@
+/**
+ * 업데이트 체크 모듈
+ * npm 레지스트리에서 최신 버전을 확인합니다.
+ * @module updates
+ */
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+/**
+ * 현재 설치된 버전을 반환합니다.
+ * @returns 현재 버전 문자열 (예: "0.6.0")
+ */
+export function getCurrentVersion() {
+    // package.json에서 버전 읽기
+    return require("../../package.json").version;
+}
+/**
+ * npm 레지스트리에서 최신 버전을 확인합니다.
+ * @returns 업데이트 정보 (현재 버전, 최신 버전, 업데이트 가능 여부)
+ */
+export async function checkForUpdates() {
+    const current = getCurrentVersion();
+    try {
+        const { stdout } = await execAsync("npm view companionbot version");
+        const latest = stdout.trim();
+        return {
+            current,
+            latest,
+            hasUpdate: latest !== current && compareVersions(latest, current) > 0
+        };
+    }
+    catch {
+        return { current, latest: current, hasUpdate: false };
+    }
+}
+/**
+ * 두 semver 버전을 비교합니다.
+ * @param a - 첫 번째 버전
+ * @param b - 두 번째 버전
+ * @returns a > b면 1, a < b면 -1, 같으면 0
+ */
+function compareVersions(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (pa[i] > pb[i])
+            return 1;
+        if (pa[i] < pb[i])
+            return -1;
+    }
+    return 0;
+}