companionbot 0.5.0 → 0.7.0

package/README.md

@@ -29,12 +29,21 @@
 - **일회성 예약** - "내일 오전 9시에 알려줘"
 - **반복 작업** - "30분마다 주식 가격 확인해줘"
 
-### 🤖 고급 기능 (v0.3.0)
+### 🤖 고급 기능 (v0.3.0+)
 - **서브 에이전트** - 복잡한 작업을 백그라운드에서 처리
 - **백그라운드 실행** - 긴 명령어를 백그라운드에서 실행하고 결과 확인
 - **파일 시스템** - 워크스페이스 내 파일 읽기/쓰기/편집
 - **일일 메모리** - 대화 내용 자동 저장
 
+### 🧠 시맨틱 메모리 (v0.6.0)
+- **벡터 검색** - 임베딩 기반 관련 메모리 검색
+- **자동 인덱싱** - 메모리 파일 자동 청크 분할 및 임베딩
+- **유사도 매칭** - 의미 기반으로 관련 대화 기록 찾기
+
+### 🔧 시스템 (v0.6.0)
+- **헬스 체크** - 봇 상태 모니터링 (uptime, 메시지 수, 오류 수)
+- **업데이트 알림** - 새 버전 출시 시 자동 알림
+
 ## 설치
 
 ### 사전 준비
@@ -273,7 +282,22 @@ npm test       # 테스트 실행
 
 ## 버전 히스토리
 
-### v0.3.0 (현재)
+### v0.6.0 (현재)
+- 🧠 시맨틱 메모리 검색 (임베딩 기반)
+- 💚 헬스 체크 모니터링
+- 🔄 자동 업데이트 알림
+
+### v0.5.0
+- 🔒 보안 강화 (SSRF 방지, 경로 검증)
+- ✅ 테스트 추가 (vitest)
+- 📖 문서 개선
+
+### v0.4.0
+- 🛡️ 보안 강화 (TOCTOU, 심볼릭 링크 검증)
+- 🧹 세션 자동 정리
+- 🔧 환경변수 기반 경로 설정
+
+### v0.3.0
 - 🔍 웹 검색 (Brave Search API)
 - 🕐 Cron 스케줄링 (한국어 지원)
 - 🤖 서브 에이전트 (백그라운드 작업)

package/dist/agents/index.js

@@ -1,4 +1,4 @@
 /**
  * Sub-agent 시스템 - 복잡한 작업을 독립적인 agent에게 위임
  */
-export { setAgentBot, spawnAgent, listAgents, cancelAgent, getAgent, abortAllAgents, stopCleanup } from "./manager.js";
+export { setAgentBot, spawnAgent, listAgents, cancelAgent, getAgent } from "./manager.js";

package/dist/agents/manager.js

@@ -198,14 +198,6 @@ export function cleanupOldAgents() {
         // running 상태도 1시간 지나면 정리 (stuck agent 방지)
         if (agent.status === "running" && agent.createdAt.getTime() < oneHourAgo) {
             console.log(`[Agent ${id}] Cleaning up stuck agent (running > 1h)`);
-            // 실행 중인 API 호출 취소
-            const controller = abortControllers.get(id);
-            if (controller) {
-                controller.abort();
-                abortControllers.delete(id);
-            }
-            agent.status = "cancelled";
-            agent.completedAt = new Date();
             agents.delete(id);
         }
     }
@@ -231,27 +223,5 @@ export function stopCleanup() {
         console.log("[AgentManager] Cleanup interval stopped");
     }
 }
-/**
- * 모든 진행 중인 agent abort 및 정리 (shutdown 시 사용)
- */
-export function abortAllAgents() {
-    console.log("[AgentManager] Aborting all running agents...");
-    // 모든 AbortController abort
-    for (const [id, controller] of abortControllers) {
-        console.log(`[Agent ${id}] Aborting`);
-        controller.abort();
-    }
-    abortControllers.clear();
-    // 모든 running agent 상태 업데이트
-    for (const [id, agent] of agents) {
-        if (agent.status === "running") {
-            agent.status = "cancelled";
-            agent.completedAt = new Date();
-        }
-    }
-    // cleanup interval 중지
-    stopCleanup();
-    console.log("[AgentManager] All agents aborted");
-}
 // 자동 시작
 startCleanup();

package/dist/ai/claude.js

@@ -1,5 +1,48 @@
-import Anthropic from "@anthropic-ai/sdk";
+import Anthropic, { APIError } from "@anthropic-ai/sdk";
 import { tools, executeTool } from "../tools/index.js";
+import { sleep } from "../utils/time.js";
+import { MAX_RETRIES, BASE_RETRY_DELAY_MS } from "../utils/constants.js";
+async function withRetry(fn, retries = MAX_RETRIES) {
+    let lastError = null;
+    for (let attempt = 0; attempt < retries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            // APIError 타입 체크
+            if (error instanceof APIError) {
+                lastError = error;
+                // Rate limit (429)
+                if (error.status === 429) {
+                    const retryAfter = error.headers?.["retry-after"];
+                    const delay = retryAfter
+                        ? parseInt(retryAfter) * 1000
+                        : BASE_RETRY_DELAY_MS * Math.pow(2, attempt);
+                    console.log(`[RateLimit] 429 received, waiting ${delay}ms (attempt ${attempt + 1}/${retries})`);
+                    await sleep(delay);
+                    continue;
+                }
+                // 서버 에러 (500+)
+                if (error.status >= 500) {
+                    const delay = BASE_RETRY_DELAY_MS * Math.pow(2, attempt);
+                    console.log(`[ServerError] ${error.status}, waiting ${delay}ms (attempt ${attempt + 1}/${retries})`);
+                    await sleep(delay);
+                    continue;
+                }
+            }
+            // 일반 Error 처리
+            if (error instanceof Error) {
+                lastError = error;
+            }
+            else {
+                lastError = new Error(String(error));
+            }
+            // 다른 에러는 바로 throw
+            throw error;
+        }
+    }
+    throw lastError;
+}
 let anthropic = null;
 function getClient() {
     if (!anthropic) {
@@ -7,41 +50,58 @@ function getClient() {
     }
     return anthropic;
 }
+// 모델별 max_tokens 및 thinking budget 설정
+// 참고: Claude API에서 thinking + output이 모델 한도 초과하면 안 됨
 export const MODELS = {
-    sonnet: { id: "claude-sonnet-4-20250514", name: "Claude Sonnet 4" },
-    opus: { id: "claude-opus-4-20250514", name: "Claude Opus 4" },
-    haiku: { id: "claude-haiku-3-5-20241022", name: "Claude Haiku 3.5" },
+    haiku: {
+        id: "claude-haiku-3-5-20241022",
+        name: "Claude Haiku 3.5",
+        maxTokens: 4096, // 빠른 응답
+        thinkingBudget: 0, // Haiku는 thinking 미지원
+    },
+    sonnet: {
+        id: "claude-sonnet-4-20250514",
+        name: "Claude Sonnet 4",
+        maxTokens: 8192, // 일반 작업
+        thinkingBudget: 10000, // 적당한 thinking
+    },
+    opus: {
+        id: "claude-opus-4-20250514",
+        name: "Claude Opus 4",
+        maxTokens: 16384, // 복잡한 작업
+        thinkingBudget: 32000, // 깊은 thinking
+    },
 };
-export async function chat(messages, systemPrompt, modelId = "sonnet", options) {
+export async function chat(messages, systemPrompt, modelId = "sonnet") {
     const client = getClient();
-    const model = MODELS[modelId].id;
-    const signal = options?.signal;
+    const modelConfig = MODELS[modelId];
     // 메시지를 API 형식으로 변환
     const apiMessages = messages.map((m) => ({
         role: m.role,
         content: m.content,
     }));
-    let response;
-    try {
-        response = await client.messages.create({
-            model,
-            max_tokens: 4096,
-            system: systemPrompt,
+    // API 요청 파라미터 빌드 (도구 루프에서도 동일하게 사용)
+    const buildRequestParams = () => {
+        const params = {
+            model: modelConfig.id,
+            max_tokens: modelConfig.maxTokens,
             messages: apiMessages,
             tools: tools,
-        }, { signal });
-    }
-    catch (error) {
-        if (error instanceof Anthropic.APIError) {
-            if (error.status === 429) {
-                throw new Error("API 요청이 너무 많아. 잠시 후 다시 시도해줘.");
-            }
-            if (error.status >= 500) {
-                throw new Error("AI 서버에 문제가 생겼어. 잠시 후 다시 시도해줘.");
-            }
+        };
+        if (systemPrompt) {
+            params.system = systemPrompt;
         }
-        throw error;
-    }
+        // thinking 활성화 (budget > 0인 경우)
+        if (modelConfig.thinkingBudget > 0) {
+            params.thinking = {
+                type: "enabled",
+                budget_tokens: modelConfig.thinkingBudget,
+            };
+        }
+        return params;
+    };
+    let response;
+    response = await withRetry(() => client.messages.create(buildRequestParams()));
     // Tool use 루프 - Claude가 도구 사용을 멈출 때까지 반복 (최대 10회)
     const MAX_TOOL_ITERATIONS = 10;
     let iterations = 0;
@@ -72,27 +132,8 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", options)
             role: "user",
             content: toolResults,
         });
-        // 다음 응답 요청
-        try {
-            response = await client.messages.create({
-                model,
-                max_tokens: 4096,
-                system: systemPrompt,
-                messages: apiMessages,
-                tools: tools,
-            }, { signal });
-        }
-        catch (error) {
-            if (error instanceof Anthropic.APIError) {
-                if (error.status === 429) {
-                    throw new Error("API 요청이 너무 많아. 잠시 후 다시 시도해줘.");
-                }
-                if (error.status >= 500) {
-                    throw new Error("AI 서버에 문제가 생겼어. 잠시 후 다시 시도해줘.");
-                }
-            }
-            throw error;
-        }
+        // 다음 응답 요청 (도구 루프에서도 thinking 유지)
+        response = await withRetry(() => client.messages.create(buildRequestParams()));
     }
     // 반복 횟수 초과 시 경고
     if (iterations >= MAX_TOOL_ITERATIONS) {
@@ -103,3 +144,67 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", options)
     const textBlock = response.content.find((block) => block.type === "text");
     return textBlock?.text ?? "응답을 생성하지 못했어. 다시 시도해줄래?";
 }
+/**
+ * 스마트 채팅 - 가능하면 스트리밍, 도구 필요하면 일반 호출
+ *
+ * 전략:
+ * - 먼저 스트리밍으로 시도
+ * - 도구 호출이 감지되면 (stop_reason === "tool_use") 기존 chat()으로 폴백
+ * - 스트리밍은 최종 텍스트 응답에만 사용
+ */
+export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
+    // 스트리밍 콜백이 없으면 그냥 일반 chat 사용
+    if (!onChunk) {
+        const text = await chat(messages, systemPrompt, modelId);
+        return { text, usedTools: false };
+    }
+    const client = getClient();
+    const modelConfig = MODELS[modelId];
+    // 메시지를 API 형식으로 변환
+    const apiMessages = messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+    }));
+    // 스트리밍 요청 파라미터
+    const params = {
+        model: modelConfig.id,
+        max_tokens: modelConfig.maxTokens,
+        messages: apiMessages,
+        tools: tools,
+        stream: true,
+    };
+    if (systemPrompt) {
+        params.system = systemPrompt;
+    }
+    // Thinking은 스트리밍에서 복잡해지므로 일단 비활성화
+    // (도구 호출 폴백 시 chat()에서 thinking 사용됨)
+    let accumulated = "";
+    let stopReason = null;
+    // 스트리밍에 withRetry 적용 - 실패 시 자동 재시도
+    return await withRetry(async () => {
+        accumulated = ""; // 재시도 시 초기화
+        const stream = client.messages.stream(params);
+        // 스트리밍 이벤트 처리
+        stream.on("text", async (text) => {
+            accumulated += text;
+            try {
+                await onChunk(text, accumulated);
+            }
+            catch (err) {
+                // editMessageText 실패 등은 무시하고 계속
+                console.warn("[Stream] Chunk callback error (ignored):", err);
+            }
+        });
+        // 스트림 완료 대기
+        const finalMessage = await stream.finalMessage();
+        stopReason = finalMessage.stop_reason;
+        // 도구 호출이 필요한 경우 - 일반 chat으로 폴백
+        if (stopReason === "tool_use") {
+            console.log("[Stream] Tool use detected, falling back to chat()");
+            const text = await chat(messages, systemPrompt, modelId);
+            return { text, usedTools: true };
+        }
+        // 성공적으로 스트리밍 완료
+        return { text: accumulated, usedTools: false };
+    });
+}

package/dist/calendar/index.js

@@ -1,4 +1,5 @@
-import { google } from "googleapis";
+import { calendar } from "@googleapis/calendar";
+import { OAuth2Client } from "google-auth-library";
 import * as fs from "fs/promises";
 import * as path from "path";
 import * as http from "http";
@@ -69,7 +70,7 @@ export async function getAuthUrl() {
     const creds = await loadCredentials();
     if (!creds)
         return null;
-    const oauth2Client = new google.auth.OAuth2(creds.client_id, creds.client_secret, REDIRECT_URI);
+    const oauth2Client = new OAuth2Client(creds.client_id, creds.client_secret, REDIRECT_URI);
     return oauth2Client.generateAuthUrl({
         access_type: "offline",
         scope: SCOPES,
@@ -120,7 +121,7 @@ export async function exchangeCodeForToken(code) {
     const creds = await loadCredentials();
     if (!creds)
         return false;
-    const oauth2Client = new google.auth.OAuth2(creds.client_id, creds.client_secret, REDIRECT_URI);
+    const oauth2Client = new OAuth2Client(creds.client_id, creds.client_secret, REDIRECT_URI);
     try {
         const { tokens } = await oauth2Client.getToken(code);
         if (tokens.access_token && tokens.refresh_token) {
@@ -145,7 +146,7 @@ async function getAuthClient() {
     if (!creds || !token) {
         throw new Error("Calendar not configured. Use /calendar_setup");
     }
-    const oauth2Client = new google.auth.OAuth2(creds.client_id, creds.client_secret, REDIRECT_URI);
+    const oauth2Client = new OAuth2Client(creds.client_id, creds.client_secret, REDIRECT_URI);
     oauth2Client.setCredentials({
         access_token: token.access_token,
         refresh_token: token.refresh_token,
@@ -169,17 +170,18 @@ async function getAuthClient() {
 // 캘린더 API 인스턴스
 async function getCalendar() {
     const auth = await getAuthClient();
-    return google.calendar({ version: "v3", auth });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return calendar({ version: "v3", auth: auth });
 }
 // 오늘 일정 조회
 export async function getTodayEvents() {
-    const calendar = await getCalendar();
+    const cal = await getCalendar();
     const now = new Date();
     const startOfDay = new Date(now);
     startOfDay.setHours(0, 0, 0, 0);
     const endOfDay = new Date(now);
     endOfDay.setHours(23, 59, 59, 999);
-    const response = await calendar.events.list({
+    const response = await cal.events.list({
         calendarId: "primary",
         timeMin: startOfDay.toISOString(),
         timeMax: endOfDay.toISOString(),
@@ -190,8 +192,8 @@ export async function getTodayEvents() {
 }
 // 특정 기간 일정 조회
 export async function getEvents(startDate, endDate) {
-    const calendar = await getCalendar();
-    const response = await calendar.events.list({
+    const cal = await getCalendar();
+    const response = await cal.events.list({
         calendarId: "primary",
         timeMin: startDate.toISOString(),
         timeMax: endDate.toISOString(),
@@ -203,7 +205,7 @@ export async function getEvents(startDate, endDate) {
 }
 // 일정 추가
 export async function addEvent(summary, startTime, endTime, description) {
-    const calendar = await getCalendar();
+    const cal = await getCalendar();
     // 종료 시간이 없으면 1시간 후
     const end = endTime || new Date(startTime.getTime() + 60 * 60 * 1000);
     const event = {
@@ -218,7 +220,7 @@ export async function addEvent(summary, startTime, endTime, description) {
             timeZone: "Asia/Seoul",
         },
     };
-    const response = await calendar.events.insert({
+    const response = await cal.events.insert({
         calendarId: "primary",
         requestBody: event,
     });
@@ -227,8 +229,8 @@ export async function addEvent(summary, startTime, endTime, description) {
 // 일정 삭제
 export async function deleteEvent(eventId) {
     try {
-        const calendar = await getCalendar();
-        await calendar.events.delete({
+        const cal = await getCalendar();
+        await cal.events.delete({
             calendarId: "primary",
             eventId,
         });

package/dist/cron/index.js

@@ -8,7 +8,7 @@ export { isValidCronExpression, parseCronExpression, getNextCronRun, getNextRun,
 // Storage functions
 export { loadJobs, saveJobs, addJob, removeJob, updateJob, getDueJobs, markJobExecuted, getJobsByChat, getJob, calculateNextRun, } from "./store.js";
 // Scheduler functions
-export { CronScheduler, executeJob, setCronBot, startCronScheduler, stopCronScheduler, isCronSchedulerRunning, initCronSystem, restoreCronJobs, createCronJob, deleteCronJob, toggleCronJob, getCronJobs, getAllCronJobs, getActiveJobCount, } from "./scheduler.js";
+export { CronScheduler, executeJob, setCronBot, startCronScheduler, stopCronScheduler, isCronSchedulerRunning, initCronSystem, restoreCronJobs, createCronJob, deleteCronJob, toggleCronJob, getCronJobs, getAllCronJobs, getActiveJobCount, ensureDefaultCronJobs, } from "./scheduler.js";
 // Command handlers (for tools)
 export { addCronJob, removeCronJob, setCronJobEnabled, listCronJobs, getCronStatus, } from "./commands.js";
 // Aliases for backward compatibility

package/dist/cron/parser.js

@@ -130,184 +130,83 @@ export function parseCronExpression(expr) {
     };
 }
 /**
- * Get time components in a specific timezone using Intl API
+ * Calculate the next run time for a cron expression
+ * Returns null if no valid next run time is found (safer than throwing)
  */
-function getTimeInTimezone(date, timezone) {
-    try {
-        const formatter = new Intl.DateTimeFormat("en-US", {
-            timeZone: timezone,
-            year: "numeric",
-            month: "2-digit",
-            day: "2-digit",
-            hour: "2-digit",
-            minute: "2-digit",
-            weekday: "short",
-            hour12: false,
-        });
-        const parts = formatter.formatToParts(date);
-        const getValue = (type) => parts.find((p) => p.type === type)?.value ?? "0";
-        const dayOfWeekMap = {
-            Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6,
-        };
-        return {
-            year: parseInt(getValue("year"), 10),
-            month: parseInt(getValue("month"), 10),
-            day: parseInt(getValue("day"), 10),
-            hour: parseInt(getValue("hour"), 10),
-            minute: parseInt(getValue("minute"), 10),
-            dayOfWeek: dayOfWeekMap[getValue("weekday")] ?? 0,
-        };
-    }
-    catch {
-        // Fallback to local time if timezone is invalid
-        return {
-            year: date.getFullYear(),
-            month: date.getMonth() + 1,
-            day: date.getDate(),
-            hour: date.getHours(),
-            minute: date.getMinutes(),
-            dayOfWeek: date.getDay(),
-        };
+export function getNextCronRun(expression, fromDate = new Date(), timezone) {
+    // null/undefined/빈 문자열 처리
+    if (!expression || expression.trim() === "") {
+        console.warn("[Cron] Empty cron expression provided");
+        return null;
     }
-}
-/**
- * Create a Date object for a specific time in a timezone
- */
-function createDateInTimezone(year, month, day, hour, minute, timezone) {
     try {
-        const dateStr = `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}T${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}:00`;
-        const formatter = new Intl.DateTimeFormat("en-US", {
-            timeZone: timezone,
-            year: "numeric",
-            month: "2-digit",
-            day: "2-digit",
-            hour: "2-digit",
-            minute: "2-digit",
-            hour12: false,
-        });
-        // Binary search for the correct UTC time
-        let guess = new Date(dateStr);
-        for (let i = 0; i < 3; i++) {
-            const parts = formatter.formatToParts(guess);
-            const getValue = (type) => parseInt(parts.find((p) => p.type === type)?.value ?? "0", 10);
-            const guessHour = getValue("hour");
-            const guessMinute = getValue("minute");
-            const guessDay = getValue("day");
-            let diffMinutes = (hour - guessHour) * 60 + (minute - guessMinute);
-            if (day !== guessDay) {
-                if (day > guessDay || (day === 1 && guessDay > 20)) {
-                    diffMinutes += 24 * 60;
-                }
-                else {
-                    diffMinutes -= 24 * 60;
-                }
-            }
-            if (diffMinutes === 0)
-                break;
-            guess = new Date(guess.getTime() + diffMinutes * 60 * 1000);
-        }
-        return guess;
-    }
-    catch {
-        return new Date(year, month - 1, day, hour, minute, 0, 0);
-    }
-}
-/**
- * Get number of days in a month
- */
-function getDaysInMonth(year, month) {
-    return new Date(year, month, 0).getDate();
-}
-/**
- * Calculate the next run time for a cron expression with timezone support
- */
-export function getNextCronRun(expression, fromDate = new Date(), timezone) {
-    const parsed = parseCronExpression(expression);
-    const now = fromDate;
-    const tz = timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
-    // Get current time in target timezone
-    const current = getTimeInTimezone(now, tz);
-    // Search for next valid time (up to 366 days ahead)
-    const searchDate = { ...current };
-    const maxIterations = 366 * 24 * 60;
-    for (let i = 0; i < maxIterations; i++) {
-        // Advance by one minute each iteration
-        if (i > 0) {
-            searchDate.minute++;
-            if (searchDate.minute > 59) {
-                searchDate.minute = 0;
-                searchDate.hour++;
-                if (searchDate.hour > 23) {
-                    searchDate.hour = 0;
-                    searchDate.day++;
-                    searchDate.dayOfWeek = (searchDate.dayOfWeek + 1) % 7;
-                    const daysInMonth = getDaysInMonth(searchDate.year, searchDate.month);
-                    if (searchDate.day > daysInMonth) {
-                        searchDate.day = 1;
-                        searchDate.month++;
-                        if (searchDate.month > 12) {
-                            searchDate.month = 1;
-                            searchDate.year++;
-                        }
-                    }
-                }
-            }
+        const parsed = parseCronExpression(expression);
+        const from = new Date(fromDate);
+        // Invalid date 체크
+        if (isNaN(from.getTime())) {
+            console.warn("[Cron] Invalid fromDate provided");
+            return null;
         }
-        // Check if this time matches all constraints
-        if (!parsed.month.values.includes(searchDate.month))
-            continue;
-        // For dayOfMonth and dayOfWeek: if both are restricted, match either (OR logic)
-        // If only one is restricted, use that one
-        const domRestricted = parsed.dayOfMonth.type !== "wildcard";
-        const dowRestricted = parsed.dayOfWeek.type !== "wildcard";
-        if (domRestricted && dowRestricted) {
-            // Both restricted: match either
-            if (!parsed.dayOfMonth.values.includes(searchDate.day) &&
-                !parsed.dayOfWeek.values.includes(searchDate.dayOfWeek)) {
-                continue;
+        // Start from the next minute
+        from.setSeconds(0);
+        from.setMilliseconds(0);
+        from.setMinutes(from.getMinutes() + 1);
+        // Search for the next matching time (max 2 years ahead)
+        const maxIterations = 365 * 24 * 60 * 2; // 2 years in minutes
+        for (let i = 0; i < maxIterations; i++) {
+            const candidate = new Date(from.getTime() + i * 60000);
+            const minute = candidate.getMinutes();
+            const hour = candidate.getHours();
+            const dayOfMonth = candidate.getDate();
+            const month = candidate.getMonth() + 1;
+            const dayOfWeek = candidate.getDay();
+            if (parsed.minute.values.includes(minute) &&
+                parsed.hour.values.includes(hour) &&
+                parsed.month.values.includes(month) &&
+                (parsed.dayOfMonth.values.includes(dayOfMonth) ||
+                    parsed.dayOfWeek.values.includes(dayOfWeek))) {
+                return candidate;
             }
         }
-        else if (domRestricted) {
-            if (!parsed.dayOfMonth.values.includes(searchDate.day))
-                continue;
-        }
-        else if (dowRestricted) {
-            if (!parsed.dayOfWeek.values.includes(searchDate.dayOfWeek))
-                continue;
-        }
-        if (!parsed.hour.values.includes(searchDate.hour))
-            continue;
-        if (!parsed.minute.values.includes(searchDate.minute))
-            continue;
-        // Skip if this is the current minute (must be in the future)
-        if (i === 0)
-            continue;
-        // Create the date in the target timezone
-        const nextRun = createDateInTimezone(searchDate.year, searchDate.month, searchDate.day, searchDate.hour, searchDate.minute, tz);
-        // Verify it's in the future
-        if (nextRun > now) {
-            return nextRun;
-        }
+        console.warn(`[Cron] Could not find next run time for: ${expression}`);
+        return null;
+    }
+    catch (error) {
+        console.error(`[Cron] Error parsing expression "${expression}":`, error);
+        return null;
     }
-    throw new Error(`Could not find next run time for: ${expression}`);
 }
 /**
  * Get the next run time for any schedule type
+ * Returns NaN if schedule is invalid (check with isNaN())
  */
 export function getNextRun(schedule, now = new Date()) {
+    // null/undefined 처리
+    if (!schedule) {
+        console.warn("[Cron] No schedule provided to getNextRun");
+        return NaN;
+    }
     switch (schedule.kind) {
         case "at":
-            return schedule.atMs;
+            return schedule.atMs ?? NaN;
         case "every": {
+            const everyMs = schedule.everyMs || schedule.intervalMs;
+            if (!everyMs || everyMs <= 0) {
+                console.warn("[Cron] Invalid everyMs in schedule");
+                return NaN;
+            }
             const startMs = schedule.startMs ?? now.getTime();
             const elapsed = now.getTime() - startMs;
-            const intervals = Math.floor(elapsed / schedule.everyMs);
-            return startMs + (intervals + 1) * schedule.everyMs;
+            const intervals = Math.floor(elapsed / everyMs);
+            return startMs + (intervals + 1) * everyMs;
+        }
+        case "cron": {
+            const nextRun = getNextCronRun(schedule.expression, now, schedule.timezone);
+            return nextRun ? nextRun.getTime() : NaN;
         }
-        case "cron":
-            return getNextCronRun(schedule.expression, now, schedule.timezone).getTime();
         default:
-            throw new Error(`Unknown schedule kind: ${schedule.kind}`);
+            console.warn(`[Cron] Unknown schedule kind: ${schedule.kind}`);
+            return NaN;
     }
 }
 /**