companionbot 0.6.0 → 0.8.0

package/dist/cron/scheduler.js

@@ -7,6 +7,8 @@
 import { getDueJobs, markJobExecuted, loadJobs, addJob, removeJob, updateJob, getJobsByChat } from "./store.js";
 import { chat } from "../ai/claude.js";
 import { buildSystemPrompt } from "../telegram/utils/prompt.js";
+import { INTERVAL_1_MINUTE } from "../utils/time.js";
+import { TELEGRAM_SAFE_LIMIT } from "../utils/constants.js";
 // Scheduler state
 let schedulerInterval = null;
 let botInstance = null;
@@ -36,7 +38,7 @@ export class CronScheduler {
         // Then check every minute
         this.interval = setInterval(() => {
             this.checkAndRun().catch((err) => console.error("[CronScheduler] Check failed:", err));
-        }, 60 * 1000); // 1 minute
+        }, INTERVAL_1_MINUTE);
         console.log("[CronScheduler] Started - checking every minute");
     }
     /**
@@ -167,21 +169,24 @@ async function executeAgentTurn(job, payload, bot) {
         // Call Claude API
         const response = await chat(messages, systemPrompt, "sonnet");
         // Send the response to the chat
-        if (response && response.trim()) {
+        const trimmedResponse = response?.trim();
+        if (trimmedResponse) {
             // Split long messages (Telegram limit is 4096 characters)
-            const maxLength = 4000;
-            if (response.length <= maxLength) {
-                await bot.api.sendMessage(job.chatId, response, {
+            const maxLength = TELEGRAM_SAFE_LIMIT;
+            if (trimmedResponse.length <= maxLength) {
+                await bot.api.sendMessage(job.chatId, trimmedResponse, {
                     parse_mode: "Markdown",
                 });
             }
             else {
                 // Split into multiple messages
-                const chunks = splitMessage(response, maxLength);
+                const chunks = splitMessage(trimmedResponse, maxLength);
                 for (const chunk of chunks) {
-                    await bot.api.sendMessage(job.chatId, chunk, {
-                        parse_mode: "Markdown",
-                    });
+                    if (chunk) {
+                        await bot.api.sendMessage(job.chatId, chunk, {
+                            parse_mode: "Markdown",
+                        });
+                    }
                 }
             }
         }
@@ -202,6 +207,10 @@ async function executeAgentTurn(job, payload, bot) {
  * Split a long message into chunks
  */
 function splitMessage(text, maxLength) {
+    // null/undefined/빈 문자열 처리
+    if (!text || text.trim().length === 0) {
+        return [];
+    }
     const chunks = [];
     let remaining = text;
     while (remaining.length > 0) {

package/dist/cron/store.js

@@ -6,13 +6,11 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { getWorkspacePath } from "../workspace/paths.js";
+import { sleep } from "../utils/time.js";
+import { LOCK_TIMEOUT_MS, LOCK_RETRY_MS, LOCK_MAX_RETRIES } from "../utils/constants.js";
 const CRON_FILE = "cron-jobs.json";
 const LOCK_FILE = "cron-jobs.lock";
 const STORE_VERSION = 1;
-// Lock configuration
-const LOCK_TIMEOUT_MS = 5000;
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100;
 function getCronFilePath() {
     return path.join(getWorkspacePath(), CRON_FILE);
 }
@@ -73,9 +71,6 @@ async function releaseLock() {
         // Ignore errors on unlock
     }
 }
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 /**
  * Execute a function with file lock protection
  */
@@ -94,13 +89,39 @@ async function withLock(fn) {
 async function loadJobsInternal() {
     try {
         const data = await fs.readFile(getCronFilePath(), "utf-8");
+        // 빈 파일 체크
+        if (!data || data.trim() === "") {
+            return [];
+        }
         const store = JSON.parse(data);
-        return store.jobs || [];
+        // jobs 배열 유효성 검사
+        if (!store || !Array.isArray(store.jobs)) {
+            console.warn("[Cron] Invalid store format, returning empty array");
+            return [];
+        }
+        return store.jobs;
     }
     catch (error) {
         if (error.code === "ENOENT") {
             return [];
         }
+        // JSON 파싱 오류
+        if (error instanceof SyntaxError) {
+            console.error("[Cron] Corrupted cron-jobs.json file:", error.message);
+            // 백업 파일 생성 시도
+            try {
+                const backupPath = `${getCronFilePath()}.corrupted.${Date.now()}`;
+                const data = await fs.readFile(getCronFilePath(), "utf-8").catch(() => "");
+                if (data) {
+                    await fs.writeFile(backupPath, data, "utf-8");
+                    console.log(`[Cron] Corrupted file backed up to: ${backupPath}`);
+                }
+            }
+            catch {
+                // 백업 실패는 무시
+            }
+            return [];
+        }
         console.error("[Cron] Failed to load jobs:", error);
         return [];
     }
@@ -446,12 +467,21 @@ function getDaysInMonth(year, month) {
  * Parse cron field like "1,3,5" or "1-5" or step values into array of numbers
  */
 function parseCronField(field, min, max) {
-    if (field === "*") {
+    // 빈 문자열/null/undefined 처리
+    if (!field || field.trim() === "") {
+        return Array.from({ length: max - min + 1 }, (_, i) => i + min); // wildcard로 처리
+    }
+    const trimmedField = field.trim();
+    if (trimmedField === "*") {
         return Array.from({ length: max - min + 1 }, (_, i) => i + min);
     }
     // Handle step values like */5
-    if (field.startsWith("*/")) {
-        const step = parseInt(field.slice(2), 10);
+    if (trimmedField.startsWith("*/")) {
+        const step = parseInt(trimmedField.slice(2), 10);
+        if (isNaN(step) || step <= 0) {
+            console.warn(`[Cron] Invalid step value in field: ${field}, using default`);
+            return Array.from({ length: max - min + 1 }, (_, i) => i + min);
+        }
         const values = [];
         for (let i = min; i <= max; i += step) {
             values.push(i);
@@ -459,39 +489,66 @@ function parseCronField(field, min, max) {
         return values;
     }
     const values = [];
-    const parts = field.split(",");
+    const parts = trimmedField.split(",");
     for (const part of parts) {
-        if (part.includes("-")) {
-            const [start, end] = part.split("-").map(Number);
-            for (let i = start; i <= end; i++) {
-                values.push(i);
+        const trimmedPart = part.trim();
+        if (!trimmedPart)
+            continue;
+        if (trimmedPart.includes("-") && !trimmedPart.includes("/")) {
+            const [startStr, endStr] = trimmedPart.split("-");
+            const start = Number(startStr);
+            const end = Number(endStr);
+            if (!isNaN(start) && !isNaN(end)) {
+                for (let i = start; i <= end; i++) {
+                    values.push(i);
+                }
             }
         }
-        else if (part.includes("/")) {
+        else if (trimmedPart.includes("/")) {
             // Handle range with step like 0-30/5
-            const [range, stepStr] = part.split("/");
+            const [range, stepStr] = trimmedPart.split("/");
             const step = parseInt(stepStr, 10);
+            if (isNaN(step) || step <= 0)
+                continue;
             let rangeStart = min;
             let rangeEnd = max;
-            if (range.includes("-")) {
-                [rangeStart, rangeEnd] = range.split("-").map(Number);
+            if (range && range.includes("-")) {
+                const [rs, re] = range.split("-").map(Number);
+                if (!isNaN(rs))
+                    rangeStart = rs;
+                if (!isNaN(re))
+                    rangeEnd = re;
             }
             for (let i = rangeStart; i <= rangeEnd; i += step) {
                 values.push(i);
             }
         }
         else {
-            values.push(parseInt(part, 10));
+            const num = parseInt(trimmedPart, 10);
+            if (!isNaN(num)) {
+                values.push(num);
+            }
         }
     }
-    return values.filter((v) => v >= min && v <= max);
+    // 유효한 값이 없으면 wildcard로 폴백
+    const filtered = values.filter((v) => v >= min && v <= max);
+    return filtered.length > 0 ? filtered : Array.from({ length: max - min + 1 }, (_, i) => i + min);
 }
 /**
  * Get all jobs for a specific chat
  */
 export async function getJobsByChat(chatId) {
+    // null/undefined 처리
+    if (chatId == null) {
+        return [];
+    }
     const jobs = await loadJobs();
     const numericChatId = typeof chatId === "string" ? parseInt(chatId, 10) : chatId;
+    // NaN 체크
+    if (isNaN(numericChatId)) {
+        console.warn(`[Cron] Invalid chatId: ${chatId}`);
+        return [];
+    }
     return jobs.filter((j) => j.chatId === numericChatId);
 }
 /**

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 ? "정상 ✅" : "점검 필요 ⚠️"}`);
+    });
 }