companionbot 0.3.0 → 0.4.1

package/dist/telegram/handlers/commands.js

@@ -1,5 +1,27 @@
+import { randomBytes } from "crypto";
 import { chat, MODELS } from "../../ai/claude.js";
-import { getHistory, clearHistory, getModel, setModel, setCurrentChatId, } from "../../session/state.js";
+// Reset 토큰 관리 (1분 만료)
+const resetTokens = new Map();
+function generateResetToken(chatId) {
+    const token = randomBytes(8).toString("hex");
+    const expiresAt = Date.now() + 60000; // 1분 후 만료
+    resetTokens.set(chatId, { token, expiresAt });
+    return token;
+}
+function validateResetToken(chatId, token) {
+    const stored = resetTokens.get(chatId);
+    if (!stored)
+        return false;
+    if (Date.now() > stored.expiresAt) {
+        resetTokens.delete(chatId);
+        return false;
+    }
+    if (stored.token !== token)
+        return false;
+    resetTokens.delete(chatId); // 사용 후 삭제
+    return true;
+}
+import { getHistory, clearHistory, getModel, setModel, runWithChatId, } from "../../session/state.js";
 import { hasBootstrap, loadRecentMemories, getWorkspacePath, } from "../../workspace/index.js";
 import { getSecret, setSecret, deleteSecret } from "../../config/secrets.js";
 import { getReminders } from "../../reminders/index.js";
@@ -13,32 +35,33 @@ export function registerCommands(bot) {
         const chatId = ctx.chat.id;
         clearHistory(chatId);
         setModel(chatId, "sonnet");
-        setCurrentChatId(chatId);
         // 워크스페이스 캐시 무효화
         invalidateWorkspaceCache();
         // BOOTSTRAP 모드 확인
         const isBootstrap = await hasBootstrap();
         if (isBootstrap) {
-            // 온보딩 모드: 봇이 먼저 인사
-            await ctx.replyWithChatAction("typing");
-            const history = getHistory(chatId);
-            const modelId = getModel(chatId);
-            const systemPrompt = await buildSystemPrompt(modelId);
-            // 첫 메시지 생성 요청
-            history.push({
-                role: "user",
-                content: "[시스템: 사용자가 /start를 눌렀습니다. 온보딩을 시작하세요.]",
+            // 온보딩 모드: 봇이 먼저 인사 (runWithChatId로 감싸서 도구가 chatId 접근 가능)
+            await runWithChatId(chatId, async () => {
+                await ctx.replyWithChatAction("typing");
+                const history = getHistory(chatId);
+                const modelId = getModel(chatId);
+                const systemPrompt = await buildSystemPrompt(modelId);
+                // 첫 메시지 생성 요청
+                history.push({
+                    role: "user",
+                    content: "[시스템: 사용자가 /start를 눌렀습니다. 온보딩을 시작하세요.]",
+                });
+                try {
+                    const response = await chat(history, systemPrompt, modelId);
+                    history.push({ role: "assistant", content: response });
+                    await ctx.reply(response);
+                }
+                catch (error) {
+                    console.error("Bootstrap start error:", error);
+                    await ctx.reply("안녕! 반가워. 난 방금 태어난 AI야. 아직 이름도 없어.\n" +
+                        "너와 함께 나를 만들어가고 싶은데... 혹시 이름 지어줄 수 있어?");
+                }
             });
-            try {
-                const response = await chat(history, systemPrompt, modelId);
-                history.push({ role: "assistant", content: response });
-                await ctx.reply(response);
-            }
-            catch (error) {
-                console.error("Bootstrap start error:", error);
-                await ctx.reply("안녕! 반가워. 난 방금 태어난 AI야. 아직 이름도 없어.\n" +
-                    "너와 함께 나를 만들어가고 싶은데... 혹시 이름 지어줄 수 있어?");
-            }
         }
         else {
             // 일반 모드
@@ -51,20 +74,30 @@ export function registerCommands(bot) {
                 `/reset - 페르소나 리셋`);
         }
     });
-    // /reset 명령어 - 페르소나 리셋
+    // /reset 명령어 - 페르소나 리셋 (토큰 기반)
     bot.command("reset", async (ctx) => {
-        await ctx.reply("정말 페르소나를 리셋할까요?\n" +
+        const chatId = ctx.chat.id;
+        const token = generateResetToken(chatId);
+        await ctx.reply("⚠️ 정말 페르소나를 리셋할까요?\n" +
             "모든 설정이 초기화되고 온보딩을 다시 진행합니다.\n\n" +
-            "확인하려면 /confirm_reset 을 입력하세요.");
+            `확인하려면 /confirm_reset_${token} 을 입력하세요.\n` +
+            "(1분 후 만료)");
     });
-    bot.command("confirm_reset", async (ctx) => {
+    // /confirm_reset_<token> 패턴 매칭
+    bot.hears(/^\/confirm_reset_([a-f0-9]+)$/, async (ctx) => {
+        const chatId = ctx.chat.id;
+        const token = ctx.match[1];
+        if (!validateResetToken(chatId, token)) {
+            await ctx.reply("❌ 유효하지 않거나 만료된 토큰입니다.\n/reset 으로 다시 시도하세요.");
+            return;
+        }
         const { initWorkspace } = await import("../../workspace/index.js");
         const { rm } = await import("fs/promises");
         try {
             await rm(getWorkspacePath(), { recursive: true, force: true });
             await initWorkspace();
             invalidateWorkspaceCache();
-            clearHistory(ctx.chat.id);
+            clearHistory(chatId);
             await ctx.reply("✓ 페르소나가 리셋되었습니다.\n" +
                 "/start 를 눌러 온보딩을 시작하세요.");
         }
@@ -296,11 +329,24 @@ export function registerCommands(bot) {
                 `설정 방법:\n` +
                 `1. https://openweathermap.org 가입\n` +
                 `2. API Keys에서 키 발급\n` +
-                `3. /weather_setup YOUR_API_KEY 입력`);
+                `3. /weather_setup YOUR_API_KEY 입력\n\n` +
+                `⚠️ DM에서만 설정 가능합니다 (보안)`);
+            return;
+        }
+        // DM에서만 설정 가능
+        if (ctx.chat.type !== "private") {
+            await ctx.reply("⚠️ API 키는 DM에서만 설정할 수 있어요.\n보안을 위해 개인 채팅으로 보내주세요.");
             return;
         }
+        // 메시지 삭제 (API 키 노출 방지)
+        try {
+            await ctx.api.deleteMessage(ctx.chat.id, ctx.message.message_id);
+        }
+        catch {
+            // 삭제 실패해도 계속 진행
+        }
         await setSecret("openweathermap-api-key", arg);
-        await ctx.reply("✓ 날씨 API 키가 설정되었습니다!");
+        await ctx.reply("✓ 날씨 API 키가 설정되었습니다! (보안을 위해 메시지 삭제됨)");
     });
     // /reminders 명령어 - 알림 목록
     bot.command("reminders", async (ctx) => {
@@ -382,16 +428,29 @@ export function registerCommands(bot) {
                 `   - 유형: 데스크톱 앱\n` +
                 `   - 리디렉션 URI: http://localhost:3847/oauth2callback\n\n` +
                 `5. 클라이언트 ID와 Secret 복사 후:\n` +
-                `/calendar_setup CLIENT_ID CLIENT_SECRET`);
+                `/calendar_setup CLIENT_ID CLIENT_SECRET\n\n` +
+                `⚠️ DM에서만 설정 가능합니다 (보안)`);
+            return;
+        }
+        // DM에서만 설정 가능
+        if (ctx.chat.type !== "private") {
+            await ctx.reply("⚠️ API 키는 DM에서만 설정할 수 있어요.\n보안을 위해 개인 채팅으로 보내주세요.");
             return;
         }
         // credentials 설정
         if (args.length === 2) {
             const [clientId, clientSecret] = args;
+            // 메시지 삭제 (credentials 노출 방지)
+            try {
+                await ctx.api.deleteMessage(ctx.chat.id, ctx.message.message_id);
+            }
+            catch {
+                // 삭제 실패해도 계속 진행
+            }
             await setCredentials(clientId, clientSecret);
             const authUrl = await getAuthUrl();
             if (authUrl) {
-                await ctx.reply(`✅ Credentials 저장됨!\n\n` +
+                await ctx.reply(`✅ Credentials 저장됨! (보안을 위해 메시지 삭제됨)\n\n` +
                     `아래 링크에서 인증해주세요:\n${authUrl}\n\n` +
                     `인증 완료 후 자동으로 연결됩니다.`);
                 // 인증 서버 시작

package/dist/telegram/handlers/messages.js

@@ -1,5 +1,5 @@
 import { chat } from "../../ai/claude.js";
-import { getHistory, getModel, setCurrentChatId, } from "../../session/state.js";
+import { getHistory, getModel, runWithChatId, } from "../../session/state.js";
 import { updateLastMessageTime } from "../../heartbeat/index.js";
 import { extractUrls, fetchWebContent, buildSystemPrompt, } from "../utils/index.js";
 /**
@@ -9,60 +9,61 @@ export function registerMessageHandlers(bot) {
     // 사진 메시지 처리
     bot.on("message:photo", async (ctx) => {
         const chatId = ctx.chat.id;
-        setCurrentChatId(chatId);
-        const history = getHistory(chatId);
-        const modelId = getModel(chatId);
-        await ctx.replyWithChatAction("typing");
-        try {
-            // 가장 큰 사진 선택 (마지막이 가장 큼)
-            const photo = ctx.message.photo[ctx.message.photo.length - 1];
-            const file = await ctx.api.getFile(photo.file_id);
-            if (!file.file_path) {
-                await ctx.reply("사진을 가져올 수 없어.");
-                return;
-            }
-            // 파일 크기 제한 (10MB)
-            const MAX_IMAGE_SIZE = 10 * 1024 * 1024;
-            if (file.file_size && file.file_size > MAX_IMAGE_SIZE) {
-                await ctx.reply("사진이 너무 커. 10MB 이하로 보내줄래?");
-                return;
-            }
-            // 파일 다운로드
-            const fileUrl = `https://api.telegram.org/file/bot${bot.token}/${file.file_path}`;
-            const response = await fetch(fileUrl);
-            const buffer = await response.arrayBuffer();
-            const base64 = Buffer.from(buffer).toString("base64");
-            // 캡션이 있으면 사용, 없으면 기본 질문
-            const caption = ctx.message.caption || "이 사진에 뭐가 있어?";
-            // 이미지와 텍스트를 함께 전송
-            const imageContent = [
-                {
-                    type: "image",
-                    source: {
-                        type: "base64",
-                        media_type: "image/jpeg",
-                        data: base64,
+        await runWithChatId(chatId, async () => {
+            const history = getHistory(chatId);
+            const modelId = getModel(chatId);
+            await ctx.replyWithChatAction("typing");
+            try {
+                // 가장 큰 사진 선택 (마지막이 가장 큼)
+                const photo = ctx.message.photo[ctx.message.photo.length - 1];
+                const file = await ctx.api.getFile(photo.file_id);
+                if (!file.file_path) {
+                    await ctx.reply("사진을 가져올 수 없어.");
+                    return;
+                }
+                // 파일 크기 제한 (10MB)
+                const MAX_IMAGE_SIZE = 10 * 1024 * 1024;
+                if (file.file_size && file.file_size > MAX_IMAGE_SIZE) {
+                    await ctx.reply("사진이 너무 커. 10MB 이하로 보내줄래?");
+                    return;
+                }
+                // 파일 다운로드
+                const fileUrl = `https://api.telegram.org/file/bot${bot.token}/${file.file_path}`;
+                const response = await fetch(fileUrl);
+                const buffer = await response.arrayBuffer();
+                const base64 = Buffer.from(buffer).toString("base64");
+                // 캡션이 있으면 사용, 없으면 기본 질문
+                const caption = ctx.message.caption || "이 사진에 뭐가 있어?";
+                // 이미지와 텍스트를 함께 전송
+                const imageContent = [
+                    {
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            media_type: "image/jpeg",
+                            data: base64,
+                        },
+                    },
+                    {
+                        type: "text",
+                        text: caption,
                     },
-                },
-                {
-                    type: "text",
-                    text: caption,
-                },
-            ];
-            history.push({ role: "user", content: imageContent });
-            const systemPrompt = await buildSystemPrompt(modelId);
-            const result = await chat(history, systemPrompt, modelId);
-            history.push({ role: "assistant", content: result });
-            // 히스토리 제한
-            if (history.length > 20) {
-                history.splice(0, history.length - 20);
+                ];
+                history.push({ role: "user", content: imageContent });
+                const systemPrompt = await buildSystemPrompt(modelId);
+                const result = await chat(history, systemPrompt, modelId);
+                history.push({ role: "assistant", content: result });
+                // 히스토리 제한
+                if (history.length > 20) {
+                    history.splice(0, history.length - 20);
+                }
+                await ctx.reply(result);
             }
-            await ctx.reply(result);
-        }
-        catch (error) {
-            console.error("Photo error:", error);
-            await ctx.reply("사진 분석 중 오류가 발생했어.");
-        }
+            catch (error) {
+                console.error("Photo error:", error);
+                await ctx.reply("사진 분석 중 오류가 발생했어.");
+            }
+        });
     });
     // 일반 메시지 처리
     bot.on("message:text", async (ctx) => {
@@ -71,45 +72,45 @@ export function registerMessageHandlers(bot) {
         // 빈 메시지 무시
         if (!userMessage.trim())
             return;
-        // 현재 chatId 설정 (도구에서 사용)
-        setCurrentChatId(chatId);
-        // Heartbeat 마지막 대화 시간 업데이트
-        updateLastMessageTime(chatId);
-        const history = getHistory(chatId);
-        const modelId = getModel(chatId);
-        await ctx.replyWithChatAction("typing");
-        // URL 감지 및 내용 가져오기 (병렬 처리)
-        const urls = extractUrls(userMessage);
-        let enrichedMessage = userMessage;
-        if (urls.length > 0) {
-            const urlsToFetch = urls.slice(0, 3); // 최대 3개 URL
-            const contents = await Promise.all(urlsToFetch.map((url) => fetchWebContent(url)));
-            const webContents = contents
-                .map((content, index) => {
-                if (!content)
-                    return null;
-                return `\n\n---\n📎 Link: ${urlsToFetch[index]}\n📌 Title: ${content.title}\n📄 Content:\n${content.content}\n---`;
-            })
-                .filter((item) => item !== null);
-            if (webContents.length > 0) {
-                enrichedMessage = userMessage + webContents.join("\n");
+        await runWithChatId(chatId, async () => {
+            // Heartbeat 마지막 대화 시간 업데이트
+            updateLastMessageTime(chatId);
+            const history = getHistory(chatId);
+            const modelId = getModel(chatId);
+            await ctx.replyWithChatAction("typing");
+            // URL 감지 및 내용 가져오기 (병렬 처리)
+            const urls = extractUrls(userMessage);
+            let enrichedMessage = userMessage;
+            if (urls.length > 0) {
+                const urlsToFetch = urls.slice(0, 3); // 최대 3개 URL
+                const contents = await Promise.all(urlsToFetch.map((url) => fetchWebContent(url)));
+                const webContents = contents
+                    .map((content, index) => {
+                    if (!content)
+                        return null;
+                    return `\n\n---\n📎 Link: ${urlsToFetch[index]}\n📌 Title: ${content.title}\n📄 Content:\n${content.content}\n---`;
+                })
+                    .filter((item) => item !== null);
+                if (webContents.length > 0) {
+                    enrichedMessage = userMessage + webContents.join("\n");
+                }
+            }
+            // 사용자 메시지 추가 (URL 내용 포함)
+            history.push({ role: "user", content: enrichedMessage });
+            try {
+                const systemPrompt = await buildSystemPrompt(modelId);
+                const response = await chat(history, systemPrompt, modelId);
+                history.push({ role: "assistant", content: response });
+                // 히스토리 제한 (최근 20개 메시지만 유지)
+                if (history.length > 20) {
+                    history.splice(0, history.length - 20);
+                }
+                await ctx.reply(response);
             }
-        }
-        // 사용자 메시지 추가 (URL 내용 포함)
-        history.push({ role: "user", content: enrichedMessage });
-        try {
-            const systemPrompt = await buildSystemPrompt(modelId);
-            const response = await chat(history, systemPrompt, modelId);
-            history.push({ role: "assistant", content: response });
-            // 히스토리 제한 (최근 20개 메시지만 유지)
-            if (history.length > 20) {
-                history.splice(0, history.length - 20);
+            catch (error) {
+                console.error("Chat error:", error);
+                await ctx.reply("뭔가 잘못됐어. 다시 시도해줄래?");
             }
-            await ctx.reply(response);
-        }
-        catch (error) {
-            console.error("Chat error:", error);
-            await ctx.reply("뭔가 잘못됐어. 다시 시도해줄래?");
-        }
+        });
     });
 }

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";
+// 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";
 import { createReminder, deleteReminder, getReminders, parseTimeExpression, } from "../reminders/index.js";
@@ -20,6 +21,24 @@ 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();
+    for (const [id, session] of sessions) {
+        // 완료/에러/종료된 세션만 정리
+        if (session.status !== "running" && session.endTime) {
+            const age = now - session.endTime.getTime();
+            if (age > SESSION_TTL_MS) {
+                sessions.delete(id);
+            }
+        }
+    }
+}
+// 주기적 세션 정리 시작
+setInterval(cleanupStaleSessions, SESSION_CLEANUP_INTERVAL_MS);
 function appendOutput(session, data) {
     const lines = data.split("\n");
     session.outputBuffer.push(...lines);
@@ -39,6 +58,40 @@ function getAllowedPaths() {
     ];
 }
 // 위험한 파일 패턴
+// SSRF 방지: 사설 IP 체크
+function isPrivateIP(hostname) {
+    // IPv4 사설 IP 패턴
+    const privateIPv4Patterns = [
+        /^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
+    ];
+    // IPv6 사설/특수 주소
+    const privateIPv6Patterns = [
+        /^::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)
+        /^::ffff:(127\.|10\.|172\.(1[6-9]|2[0-9]|3[0-1])\.|192\.168\.)/i, // IPv4-mapped
+    ];
+    // localhost 체크
+    if (hostname === 'localhost' || hostname === 'localhost.localdomain') {
+        return true;
+    }
+    // IPv4 체크
+    if (privateIPv4Patterns.some(p => p.test(hostname))) {
+        return true;
+    }
+    // IPv6 체크 (브라켓 제거)
+    const ipv6 = hostname.replace(/^\[|\]$/g, '');
+    if (privateIPv6Patterns.some(p => p.test(ipv6))) {
+        return true;
+    }
+    return false;
+}
 const DANGEROUS_PATTERNS = [
     /\.bashrc$/,
     /\.zshrc$/,
@@ -51,6 +104,12 @@ const DANGEROUS_PATTERNS = [
     /\.npmrc$/,
 ];
 function isPathAllowed(targetPath) {
+    // ⚠️ TOCTOU (Time-of-check to time-of-use) 주의:
+    // realpathSync() 호출과 실제 파일 작업 사이에 심볼릭 링크가 변경될 수 있음.
+    // 완전한 방지를 위해서는 O_NOFOLLOW 플래그로 파일을 열어야 하지만,
+    // Node.js fs API에서는 제한적으로만 지원됨 (fs.open의 O_NOFOLLOW 미지원).
+    // 현재 구현은 기본적인 심볼릭 링크 해석을 통한 검증만 수행.
+    // 높은 보안이 필요한 환경에서는 chroot/namespace 격리를 권장.
     try {
         const resolved = path.resolve(targetPath);
         // 위험한 파일 패턴 차단
@@ -69,7 +128,8 @@ function isPathAllowed(targetPath) {
                 realPath = path.join(fsSync.realpathSync(parentDir), path.basename(resolved));
             }
             catch {
-                realPath = resolved;
+                // 부모 디렉토리도 resolve 실패 시 거부 (존재하지 않거나 접근 불가)
+                return false;
             }
         }
         const allowedPaths = getAllowedPaths();
@@ -81,6 +141,7 @@ function isPathAllowed(targetPath) {
         });
     }
     catch {
+        // 어떤 예외든 검증 실패로 처리 (fail-safe)
         return false;
     }
 }
@@ -771,9 +832,9 @@ export async function executeTool(name, input) {
                     "grep", "find", "wc", "sort", "uniq", "diff", "echo", "date",
                     "which", "env", "printenv"
                 ];
-                // 명령어 체이닝/치환 차단 (;, &&, ||, |, `, $(), ${})
-                if (/[;&|`]|\$\(|\$\{/.test(command)) {
-                    return `Error: Command chaining and substitution not allowed.`;
+                // 명령어 체이닝/치환/리디렉션 차단 (;, &&, ||, |, `, $(), ${}, 개행, >, <)
+                if (/[;&|`\n\r]|\$\(|\$\{|>>|>|</.test(command)) {
+                    return `Error: Command chaining, substitution, and redirection not allowed.`;
                 }
                 // 첫 번째 명령어 추출
                 const parts = command.trim().split(/\s+/);
@@ -1295,6 +1356,16 @@ ${"─".repeat(40)}`;
                 if (!url.startsWith("http://") && !url.startsWith("https://")) {
                     return "Error: URL must start with http:// or https://";
                 }
+                // SSRF 방지: 사설 IP 차단
+                try {
+                    const parsedUrl = new URL(url);
+                    if (isPrivateIP(parsedUrl.hostname)) {
+                        return "Error: Access to private/internal addresses is not allowed.";
+                    }
+                }
+                catch {
+                    return "Error: Invalid URL format.";
+                }
                 try {
                     const response = await fetch(url, {
                         headers: {

package/dist/tools/pathCheck.js

@@ -0,0 +1,79 @@
+/**
+ * Path validation utilities for security
+ * 보안 크리티컬 - 허용된 경로만 접근 가능하도록 검증
+ */
+import * as fsSync from "fs";
+import * as path from "path";
+import { getWorkspacePath } from "../workspace/index.js";
+// 홈 디렉토리
+const home = process.env.HOME || "";
+// 위험한 파일 패턴
+export const DANGEROUS_PATTERNS = [
+    /\.bashrc$/,
+    /\.zshrc$/,
+    /\.bash_profile$/,
+    /\.profile$/,
+    /\.ssh\//,
+    /\.git\/hooks\//,
+    /\.git\/config$/,
+    /\.env$/,
+    /\.npmrc$/,
+];
+/**
+ * 허용된 디렉토리 목록 반환
+ */
+export function getAllowedPaths() {
+    return [
+        path.join(home, "Documents"),
+        path.join(home, "projects"),
+        getWorkspacePath(),
+    ];
+}
+/**
+ * 주어진 경로가 허용된 디렉토리 내에 있는지 검증
+ *
+ * 보안 고려사항:
+ * - 심볼릭 링크를 해석하여 실제 경로 확인
+ * - 위험한 파일 패턴 차단
+ * - 허용된 디렉토리 외부 접근 차단
+ *
+ * ⚠️ TOCTOU (Time-of-check to time-of-use) 주의:
+ * realpathSync() 호출과 실제 파일 작업 사이에 심볼릭 링크가 변경될 수 있음.
+ * 완전한 방지를 위해서는 chroot/namespace 격리를 권장.
+ */
+export function isPathAllowed(targetPath, allowedPaths) {
+    try {
+        const resolved = path.resolve(targetPath);
+        // 위험한 파일 패턴 차단
+        if (DANGEROUS_PATTERNS.some((p) => p.test(resolved))) {
+            return false;
+        }
+        // 심볼릭 링크 해제하여 실제 경로 확인
+        let realPath;
+        try {
+            realPath = fsSync.realpathSync(resolved);
+        }
+        catch {
+            // 파일이 아직 없으면 (write_file) 부모 디렉토리 확인
+            const parentDir = path.dirname(resolved);
+            try {
+                realPath = path.join(fsSync.realpathSync(parentDir), path.basename(resolved));
+            }
+            catch {
+                // 부모 디렉토리도 resolve 실패 시 거부
+                return false;
+            }
+        }
+        const allowed = allowedPaths ?? getAllowedPaths();
+        // 정확한 경로 구분자로 비교 (startsWith만으로는 ~/DocumentsEvil 같은 경로 통과)
+        return allowed.some((allowedPath) => {
+            const normalizedAllowed = path.resolve(allowedPath);
+            return (realPath === normalizedAllowed ||
+                realPath.startsWith(normalizedAllowed + path.sep));
+        });
+    }
+    catch {
+        // 어떤 예외든 검증 실패로 처리 (fail-safe)
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "companionbot",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "AI 친구 텔레그램 봇 - Claude API 기반 개인화된 대화 상대",
   "keywords": [
     "telegram",
@@ -37,11 +37,14 @@
     "dev": "tsx src/cli/main.ts",
     "start": "node dist/cli/main.js",
     "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "setup": "tsx src/cli/setup.ts",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
+    "@grammyjs/ratelimiter": "^1.2.1",
     "cheerio": "^1.2.0",
     "googleapis": "^171.4.0",
     "grammy": "^1.31.0",
@@ -52,6 +55,7 @@
     "@types/node": "^22.0.0",
     "@types/node-cron": "^3.0.11",
     "tsx": "^4.0.0",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
   }
 }