companionbot 0.3.0 → 0.4.1

package/dist/cron/store.js

@@ -1,16 +1,24 @@
 /**
  * Cron Job Store
  *
- * Persists and manages cron jobs.
+ * Persists and manages cron jobs with race condition protection.
  */
 import * as fs from "fs/promises";
 import * as path from "path";
 import { getWorkspacePath } from "../workspace/paths.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);
 }
+function getLockFilePath() {
+    return path.join(getWorkspacePath(), LOCK_FILE);
+}
 /**
  * Generate a unique ID without uuid dependency
  */
@@ -18,9 +26,72 @@ function generateId() {
     return crypto.randomUUID();
 }
 /**
- * Load all cron jobs from storage
+ * Simple file-based lock for race condition prevention
  */
-export async function loadJobs() {
+async function acquireLock() {
+    const lockPath = getLockFilePath();
+    const lockId = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+        try {
+            // Try to create lock file exclusively
+            await fs.writeFile(lockPath, lockId, { flag: "wx" });
+            return true;
+        }
+        catch (error) {
+            if (error.code === "EEXIST") {
+                // Lock exists, check if it's stale
+                try {
+                    const stat = await fs.stat(lockPath);
+                    const age = Date.now() - stat.mtimeMs;
+                    if (age > LOCK_TIMEOUT_MS) {
+                        // Stale lock, remove it
+                        await fs.unlink(lockPath).catch(() => { });
+                        continue;
+                    }
+                }
+                catch {
+                    // Lock file gone, retry immediately
+                    continue;
+                }
+                // Wait and retry
+                await sleep(LOCK_RETRY_MS);
+            }
+            else {
+                // Other error, assume we can proceed
+                return true;
+            }
+        }
+    }
+    console.warn("[Cron] Failed to acquire lock after max retries, proceeding anyway");
+    return false;
+}
+async function releaseLock() {
+    try {
+        await fs.unlink(getLockFilePath());
+    }
+    catch {
+        // Ignore errors on unlock
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Execute a function with file lock protection
+ */
+async function withLock(fn) {
+    await acquireLock();
+    try {
+        return await fn();
+    }
+    finally {
+        await releaseLock();
+    }
+}
+/**
+ * Load all cron jobs from storage (internal, no lock)
+ */
+async function loadJobsInternal() {
     try {
         const data = await fs.readFile(getCronFilePath(), "utf-8");
         const store = JSON.parse(data);
@@ -35,63 +106,92 @@ export async function loadJobs() {
     }
 }
 /**
- * Save all cron jobs to storage
+ * Save all cron jobs to storage (internal, no lock)
+ * Uses atomic write pattern: write to temp file, then rename
  */
-export async function saveJobs(jobs) {
+async function saveJobsInternal(jobs) {
     const store = {
         version: STORE_VERSION,
         jobs,
     };
-    await fs.writeFile(getCronFilePath(), JSON.stringify(store, null, 2), "utf-8");
+    const filePath = getCronFilePath();
+    const tempPath = `${filePath}.tmp.${process.pid}`;
+    try {
+        await fs.writeFile(tempPath, JSON.stringify(store, null, 2), "utf-8");
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        // Clean up temp file on error
+        await fs.unlink(tempPath).catch(() => { });
+        throw error;
+    }
+}
+/**
+ * Load all cron jobs from storage
+ */
+export async function loadJobs() {
+    return withLock(() => loadJobsInternal());
+}
+/**
+ * Save all cron jobs to storage
+ */
+export async function saveJobs(jobs) {
+    return withLock(() => saveJobsInternal(jobs));
 }
 /**
  * Add a new cron job
  */
 export async function addJob(newJob) {
-    const jobs = await loadJobs();
-    const job = {
-        ...newJob,
-        id: generateId(),
-        createdAt: new Date().toISOString(),
-        runCount: newJob.runCount ?? 0,
-    };
-    // Calculate initial nextRun
-    if (job.schedule) {
-        job.nextRun = calculateNextRun(job.schedule);
-    }
-    else {
-        // Use cronExpr to calculate next run
-        job.nextRun = calculateCronNextRun(job.cronExpr, job.timezone);
-    }
-    jobs.push(job);
-    await saveJobs(jobs);
-    return job;
+    return withLock(async () => {
+        const jobs = await loadJobsInternal();
+        const job = {
+            ...newJob,
+            id: generateId(),
+            createdAt: new Date().toISOString(),
+            runCount: newJob.runCount ?? 0,
+        };
+        // Calculate initial nextRun
+        if (job.schedule) {
+            job.nextRun = calculateNextRun(job.schedule);
+        }
+        else {
+            // Use cronExpr to calculate next run
+            job.nextRun = calculateCronNextRun(job.cronExpr, job.timezone);
+        }
+        jobs.push(job);
+        await saveJobsInternal(jobs);
+        return job;
+    });
 }
 /**
  * Remove a cron job by ID
  */
 export async function removeJob(jobId) {
-    const jobs = await loadJobs();
-    const index = jobs.findIndex((j) => j.id === jobId);
-    if (index === -1) {
-        return false;
-    }
-    jobs.splice(index, 1);
-    await saveJobs(jobs);
-    return true;
+    return withLock(async () => {
+        const jobs = await loadJobsInternal();
+        const index = jobs.findIndex((j) => j.id === jobId);
+        if (index === -1) {
+            return false;
+        }
+        jobs.splice(index, 1);
+        await saveJobsInternal(jobs);
+        return true;
+    });
 }
 /**
- * Update a cron job
+ * Update a cron job (atomic)
  */
 export async function updateJob(jobId, updates) {
-    const jobs = await loadJobs();
-    const index = jobs.findIndex((j) => j.id === jobId);
-    if (index === -1) {
-        return null;
-    }
-    jobs[index] = { ...jobs[index], ...updates };
-    await saveJobs(jobs);
-    return jobs[index];
+    return withLock(async () => {
+        const jobs = await loadJobsInternal();
+        const index = jobs.findIndex((j) => j.id === jobId);
+        if (index === -1) {
+            return null;
+        }
+        jobs[index] = { ...jobs[index], ...updates };
+        await saveJobsInternal(jobs);
+        return jobs[index];
+    });
 }
 /**
  * Get jobs that are due to run
@@ -112,30 +212,32 @@ export async function getDueJobs() {
     });
 }
 /**
- * Mark a job as executed and update nextRun
+ * Mark a job as executed and update nextRun (atomic)
  */
 export async function markJobExecuted(jobId) {
-    const jobs = await loadJobs();
-    const job = jobs.find((j) => j.id === jobId);
-    if (!job)
-        return;
-    job.lastRun = new Date().toISOString();
-    job.runCount = (job.runCount || 0) + 1;
-    // Check if job should be disabled (one-time jobs)
-    if (job.maxRuns !== undefined && job.runCount >= job.maxRuns) {
-        job.enabled = false;
-        job.nextRun = undefined;
-    }
-    else {
-        // Calculate next run
-        if (job.schedule) {
-            job.nextRun = calculateNextRun(job.schedule);
+    await withLock(async () => {
+        const jobs = await loadJobsInternal();
+        const job = jobs.find((j) => j.id === jobId);
+        if (!job)
+            return;
+        job.lastRun = new Date().toISOString();
+        job.runCount = (job.runCount || 0) + 1;
+        // Check if job should be disabled (one-time jobs)
+        if (job.maxRuns !== undefined && job.runCount >= job.maxRuns) {
+            job.enabled = false;
+            job.nextRun = undefined;
         }
         else {
-            job.nextRun = calculateCronNextRun(job.cronExpr, job.timezone);
+            // Calculate next run
+            if (job.schedule) {
+                job.nextRun = calculateNextRun(job.schedule);
+            }
+            else {
+                job.nextRun = calculateCronNextRun(job.cronExpr, job.timezone);
+            }
         }
-    }
-    await saveJobs(jobs);
+        await saveJobsInternal(jobs);
+    });
 }
 /**
  * Calculate the next run time for a schedule
@@ -164,49 +266,198 @@ export function calculateNextRun(schedule) {
     }
 }
 /**
- * Parse and calculate next run for cron expression
+ * Get current time components in a specific timezone
+ */
+function getTimeInTimezone(date, timezone) {
+    try {
+        // Use Intl.DateTimeFormat to get time in target timezone
+        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(),
+        };
+    }
+}
+/**
+ * Create a Date object for a specific time in a timezone
+ */
+function createDateInTimezone(year, month, day, hour, minute, timezone) {
+    try {
+        // Create a date string and parse it in the target timezone
+        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`;
+        // Get the offset for this date/time in the target timezone
+        const testDate = new Date(dateStr + "Z");
+        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 that gives us the target local time
+        // Start with a guess assuming no offset
+        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");
+            // Calculate difference in minutes
+            let diffMinutes = (hour - guessHour) * 60 + (minute - guessMinute);
+            // Handle day wrap
+            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 {
+        // Fallback: create local date
+        return new Date(year, month - 1, day, hour, minute, 0, 0);
+    }
+}
+/**
+ * Parse and calculate next run for cron expression with timezone support
  * Supports: minute hour day month weekday
  */
-function calculateCronNextRun(expression, _timezone) {
-    // Basic implementation - for production, use node-cron or cron-parser
+function calculateCronNextRun(expression, timezone) {
     const parts = expression.split(" ");
     if (parts.length !== 5) {
         console.error("[Cron] Invalid cron expression:", expression);
         return undefined;
     }
-    const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+    const [minuteExpr, hourExpr, dayOfMonthExpr, monthExpr, dayOfWeekExpr] = parts;
     const now = new Date();
-    // Simple case: specific minute and hour (e.g., "0 9 * * *" = 9:00 every day)
-    if (minute !== "*" && hour !== "*" && dayOfMonth === "*" && month === "*") {
-        const targetMinute = parseInt(minute, 10);
-        const targetHour = parseInt(hour, 10);
-        const next = new Date(now);
-        next.setHours(targetHour, targetMinute, 0, 0);
-        // If already passed today, schedule for tomorrow
-        if (next <= now) {
-            next.setDate(next.getDate() + 1);
-        }
-        // Check day of week constraint
-        if (dayOfWeek !== "*") {
-            const targetDays = parseCronField(dayOfWeek, 0, 6);
-            while (!targetDays.includes(next.getDay())) {
-                next.setDate(next.getDate() + 1);
+    const tz = timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+    // Get current time in target timezone
+    const current = getTimeInTimezone(now, tz);
+    // Parse cron fields
+    const targetMinutes = parseCronField(minuteExpr, 0, 59);
+    const targetHours = parseCronField(hourExpr, 0, 23);
+    const targetDaysOfMonth = parseCronField(dayOfMonthExpr, 1, 31);
+    const targetMonths = parseCronField(monthExpr, 1, 12);
+    const targetDaysOfWeek = parseCronField(dayOfWeekExpr, 0, 6);
+    // Search for next valid time (up to 366 days ahead)
+    let searchDate = { ...current };
+    const maxIterations = 366 * 24 * 60; // Max 1 year of minutes
+    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;
+                    // Handle month overflow (simplified - assumes 31 days)
+                    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++;
+                        }
+                    }
+                }
             }
         }
-        return next.toISOString();
+        // Check if this time matches all constraints
+        if (!targetMonths.includes(searchDate.month))
+            continue;
+        if (!targetDaysOfMonth.includes(searchDate.day))
+            continue;
+        if (!targetDaysOfWeek.includes(searchDate.dayOfWeek))
+            continue;
+        if (!targetHours.includes(searchDate.hour))
+            continue;
+        if (!targetMinutes.includes(searchDate.minute))
+            continue;
+        // Skip if this is the current minute or in the past
+        if (i === 0) {
+            // First iteration - must be in the future
+            continue;
+        }
+        // Found a match - 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.toISOString();
+        }
     }
-    // Default: next minute for complex expressions
-    const next = new Date(now.getTime() + 60000);
-    next.setSeconds(0, 0);
-    return next.toISOString();
+    console.warn("[Cron] Could not find next run time for:", expression);
+    return undefined;
+}
+/**
+ * Get number of days in a month
+ */
+function getDaysInMonth(year, month) {
+    return new Date(year, month, 0).getDate();
 }
 /**
- * Parse cron field like "1,3,5" or "1-5" into array of numbers
+ * Parse cron field like "1,3,5" or "1-5" or step values into array of numbers
  */
 function parseCronField(field, min, max) {
     if (field === "*") {
         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);
+        const values = [];
+        for (let i = min; i <= max; i += step) {
+            values.push(i);
+        }
+        return values;
+    }
     const values = [];
     const parts = field.split(",");
     for (const part of parts) {
@@ -216,11 +467,24 @@ function parseCronField(field, min, max) {
                 values.push(i);
             }
         }
+        else if (part.includes("/")) {
+            // Handle range with step like 0-30/5
+            const [range, stepStr] = part.split("/");
+            const step = parseInt(stepStr, 10);
+            let rangeStart = min;
+            let rangeEnd = max;
+            if (range.includes("-")) {
+                [rangeStart, rangeEnd] = range.split("-").map(Number);
+            }
+            for (let i = rangeStart; i <= rangeEnd; i += step) {
+                values.push(i);
+            }
+        }
         else {
             values.push(parseInt(part, 10));
         }
     }
-    return values;
+    return values.filter((v) => v >= min && v <= max);
 }
 /**
  * Get all jobs for a specific chat

package/dist/session/state.js

@@ -1,8 +1,11 @@
+import { AsyncLocalStorage } from "async_hooks";
 // 세션 설정
 const MAX_SESSIONS = 100;
 const SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24시간
 // 세션별 상태 저장
 const sessions = new Map();
+// AsyncLocalStorage for chatId context
+const chatIdStorage = new AsyncLocalStorage();
 function getSession(chatId) {
     const existing = sessions.get(chatId);
     const now = Date.now();
@@ -50,13 +53,19 @@ export function getModel(chatId) {
 export function setModel(chatId, modelId) {
     getSession(chatId).model = modelId;
 }
-// 현재 활성 chatId (도구에서 사용)
-let currentChatId = null;
-export function setCurrentChatId(chatId) {
-    currentChatId = chatId;
+/**
+ * Run a function with chatId context using AsyncLocalStorage.
+ * All code inside the callback can access the chatId via getCurrentChatId().
+ */
+export function runWithChatId(chatId, fn) {
+    return chatIdStorage.run(chatId, fn);
 }
+/**
+ * Get the current chatId from AsyncLocalStorage context.
+ * Returns null if called outside of runWithChatId().
+ */
 export function getCurrentChatId() {
-    return currentChatId;
+    return chatIdStorage.getStore() ?? null;
 }
 // 세션 정리 (수동 호출용)
 export function cleanupExpiredSessions() {

package/dist/telegram/bot.js

@@ -1,4 +1,5 @@
 import { Bot } from "grammy";
+import { limit } from "@grammyjs/ratelimiter";
 import { setBotInstance, restoreReminders } from "../reminders/index.js";
 import { setBriefingBot, restoreBriefings } from "../briefing/index.js";
 import { setHeartbeatBot, restoreHeartbeats } from "../heartbeat/index.js";
@@ -26,6 +27,14 @@ export function createBot(token) {
     // Cron 시스템 초기화
     setCronBot(bot);
     restoreCronJobs().catch((err) => console.error("Failed to restore cron jobs:", err));
+    // Rate limiting - 1분에 10개 메시지
+    bot.use(limit({
+        timeFrame: 60000, // 1분
+        limit: 10,
+        onLimitExceeded: async (ctx) => {
+            await ctx.reply("⚠️ 너무 빠르게 메시지를 보내고 있어요. 잠시 후 다시 시도해주세요.");
+        },
+    }));
     // 에러 핸들링
     bot.catch((err) => {
         console.error("Bot error:", err);