@grinev/opencode-telegram-bot 0.11.4 → 0.12.0

package/dist/scheduled-task/next-run.js

@@ -0,0 +1,207 @@
+const MINUTE_MS = 60_000;
+const MAX_SEARCH_MINUTES = 60 * 24 * 366 * 2;
+const MONTH_ALIASES = {
+    jan: 1,
+    feb: 2,
+    mar: 3,
+    apr: 4,
+    may: 5,
+    jun: 6,
+    jul: 7,
+    aug: 8,
+    sep: 9,
+    oct: 10,
+    nov: 11,
+    dec: 12,
+};
+const WEEKDAY_ALIASES = {
+    sun: 0,
+    mon: 1,
+    tue: 2,
+    wed: 3,
+    thu: 4,
+    fri: 5,
+    sat: 6,
+};
+const zonedFormatterCache = new Map();
+function getZonedFormatter(timezone) {
+    const cached = zonedFormatterCache.get(timezone);
+    if (cached) {
+        return cached;
+    }
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        weekday: "short",
+        hour12: false,
+        hourCycle: "h23",
+    });
+    zonedFormatterCache.set(timezone, formatter);
+    return formatter;
+}
+function normalizeWeekday(value) {
+    return value === 7 ? 0 : value;
+}
+function parseFieldValue(rawValue, min, max, aliases) {
+    const normalized = rawValue.trim().toLowerCase();
+    if (aliases && normalized in aliases) {
+        return aliases[normalized];
+    }
+    const parsed = Number.parseInt(normalized, 10);
+    if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+        throw new Error(`Invalid cron field value: ${rawValue}`);
+    }
+    return parsed;
+}
+function expandFieldBase(base, min, max, aliases) {
+    if (base === "*") {
+        return Array.from({ length: max - min + 1 }, (_, index) => min + index);
+    }
+    if (base.includes("-")) {
+        const [startRaw, endRaw] = base.split("-");
+        const start = parseFieldValue(startRaw, min, max, aliases);
+        const end = parseFieldValue(endRaw, min, max, aliases);
+        if (start > end) {
+            throw new Error(`Invalid cron field range: ${base}`);
+        }
+        return Array.from({ length: end - start + 1 }, (_, index) => start + index);
+    }
+    return [parseFieldValue(base, min, max, aliases)];
+}
+function expandFieldToken(token, min, max, aliases) {
+    const [baseRaw, stepRaw] = token.split("/");
+    const baseValues = expandFieldBase(baseRaw, min, max, aliases);
+    if (stepRaw === undefined) {
+        return baseValues;
+    }
+    const step = Number.parseInt(stepRaw, 10);
+    if (!Number.isInteger(step) || step <= 0) {
+        throw new Error(`Invalid cron field step: ${token}`);
+    }
+    return baseValues.filter((value, index) => {
+        if (baseRaw === "*") {
+            return (value - min) % step === 0;
+        }
+        return index % step === 0;
+    });
+}
+function parseCronField(field, min, max, aliases, normalize) {
+    const normalizedField = field.trim().toLowerCase();
+    const values = new Set();
+    for (const token of normalizedField.split(",")) {
+        const trimmedToken = token.trim();
+        if (!trimmedToken) {
+            throw new Error(`Invalid cron field: ${field}`);
+        }
+        for (const value of expandFieldToken(trimmedToken, min, max, aliases)) {
+            values.add(normalize ? normalize(value) : value);
+        }
+    }
+    return {
+        wildcard: normalizedField === "*",
+        values,
+    };
+}
+function parseCronExpression(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Unsupported cron expression: ${cron}`);
+    }
+    return {
+        minute: parseCronField(parts[0], 0, 59),
+        hour: parseCronField(parts[1], 0, 23),
+        dayOfMonth: parseCronField(parts[2], 1, 31),
+        month: parseCronField(parts[3], 1, 12, MONTH_ALIASES),
+        dayOfWeek: parseCronField(parts[4], 0, 7, WEEKDAY_ALIASES, normalizeWeekday),
+    };
+}
+function getZonedDateParts(date, timezone) {
+    const parts = getZonedFormatter(timezone).formatToParts(date);
+    const year = Number(parts.find((part) => part.type === "year")?.value);
+    const month = Number(parts.find((part) => part.type === "month")?.value);
+    const day = Number(parts.find((part) => part.type === "day")?.value);
+    const hour = Number(parts.find((part) => part.type === "hour")?.value);
+    const minute = Number(parts.find((part) => part.type === "minute")?.value);
+    const weekdayName = parts
+        .find((part) => part.type === "weekday")
+        ?.value?.toLowerCase()
+        .slice(0, 3);
+    if (!Number.isInteger(year) ||
+        !Number.isInteger(month) ||
+        !Number.isInteger(day) ||
+        !Number.isInteger(hour) ||
+        !Number.isInteger(minute) ||
+        !weekdayName ||
+        !(weekdayName in WEEKDAY_ALIASES)) {
+        throw new Error(`Failed to resolve zoned date parts for timezone: ${timezone}`);
+    }
+    return {
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        weekday: WEEKDAY_ALIASES[weekdayName],
+    };
+}
+function matchesCronField(field, value) {
+    return field.values.has(value);
+}
+function matchesCron(expression, date, timezone) {
+    const parts = getZonedDateParts(date, timezone);
+    const minuteMatch = matchesCronField(expression.minute, parts.minute);
+    const hourMatch = matchesCronField(expression.hour, parts.hour);
+    const monthMatch = matchesCronField(expression.month, parts.month);
+    const dayOfMonthMatch = matchesCronField(expression.dayOfMonth, parts.day);
+    const dayOfWeekMatch = matchesCronField(expression.dayOfWeek, parts.weekday);
+    let dayMatch = false;
+    if (expression.dayOfMonth.wildcard && expression.dayOfWeek.wildcard) {
+        dayMatch = true;
+    }
+    else if (expression.dayOfMonth.wildcard) {
+        dayMatch = dayOfWeekMatch;
+    }
+    else if (expression.dayOfWeek.wildcard) {
+        dayMatch = dayOfMonthMatch;
+    }
+    else {
+        dayMatch = dayOfMonthMatch || dayOfWeekMatch;
+    }
+    return minuteMatch && hourMatch && monthMatch && dayMatch;
+}
+export function isTaskDue(task, now = new Date()) {
+    if (!task.nextRunAt) {
+        return false;
+    }
+    const nextRunAtMs = Date.parse(task.nextRunAt);
+    if (Number.isNaN(nextRunAtMs)) {
+        return false;
+    }
+    return nextRunAtMs <= now.getTime();
+}
+export function computeNextCronRunAt(cron, timezone, fromDate = new Date()) {
+    const expression = parseCronExpression(cron);
+    let candidateMs = Math.floor(fromDate.getTime() / MINUTE_MS) * MINUTE_MS + MINUTE_MS;
+    for (let attempt = 0; attempt < MAX_SEARCH_MINUTES; attempt++) {
+        const candidate = new Date(candidateMs);
+        if (matchesCron(expression, candidate, timezone)) {
+            return candidate.toISOString();
+        }
+        candidateMs += MINUTE_MS;
+    }
+    throw new Error(`Unable to compute next cron run for expression: ${cron}`);
+}
+export function computeNextRunAt(task, fromDate = new Date()) {
+    if (task.kind === "once") {
+        const runAtMs = Date.parse(task.runAt);
+        if (Number.isNaN(runAtMs) || runAtMs <= fromDate.getTime()) {
+            return null;
+        }
+        return new Date(runAtMs).toISOString();
+    }
+    return computeNextCronRunAt(task.cron, task.timezone, fromDate);
+}

package/dist/scheduled-task/runtime.js

@@ -0,0 +1,362 @@
+import { config } from "../config.js";
+import { t } from "../i18n/index.js";
+import { logger } from "../utils/logger.js";
+import { safeBackgroundTask } from "../utils/safe-background-task.js";
+import { sendBotText } from "../bot/utils/telegram-text.js";
+import { executeScheduledTask } from "./executor.js";
+import { foregroundSessionState } from "./foreground-state.js";
+import { computeNextRunAt, isTaskDue } from "./next-run.js";
+import { getScheduledTask, listScheduledTasks, removeScheduledTask, replaceScheduledTasks, updateScheduledTask, } from "./store.js";
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const TASK_DESCRIPTION_PREVIEW_LENGTH = 64;
+const RESTART_INTERRUPTED_ERROR = "Interrupted by bot restart during scheduled task execution.";
+function splitTelegramText(text) {
+    if (text.length <= TELEGRAM_MESSAGE_LIMIT) {
+        return [text];
+    }
+    const parts = [];
+    let remaining = text;
+    while (remaining.length > TELEGRAM_MESSAGE_LIMIT) {
+        let splitIndex = remaining.lastIndexOf("\n", TELEGRAM_MESSAGE_LIMIT);
+        if (splitIndex <= 0 || splitIndex < Math.floor(TELEGRAM_MESSAGE_LIMIT * 0.5)) {
+            splitIndex = TELEGRAM_MESSAGE_LIMIT;
+        }
+        parts.push(remaining.slice(0, splitIndex).trim());
+        remaining = remaining.slice(splitIndex).trimStart();
+    }
+    if (remaining.trim()) {
+        parts.push(remaining.trim());
+    }
+    return parts;
+}
+function normalizeTaskPrompt(prompt) {
+    const normalized = prompt.replace(/\s+/g, " ").trim();
+    if (normalized.length <= TASK_DESCRIPTION_PREVIEW_LENGTH) {
+        return normalized;
+    }
+    return `${normalized.slice(0, TASK_DESCRIPTION_PREVIEW_LENGTH)}...`;
+}
+function buildSuccessDelivery(task, runAt, resultText) {
+    return {
+        taskId: task.id,
+        scheduleSummary: task.scheduleSummary,
+        prompt: task.prompt,
+        runAt,
+        status: "success",
+        messageText: t("task.run.success", {
+            description: normalizeTaskPrompt(task.prompt),
+            result: resultText,
+        }),
+    };
+}
+function buildErrorDelivery(task, runAt, errorMessage) {
+    return {
+        taskId: task.id,
+        scheduleSummary: task.scheduleSummary,
+        prompt: task.prompt,
+        runAt,
+        status: "error",
+        messageText: t("task.run.error", {
+            description: normalizeTaskPrompt(task.prompt),
+            error: errorMessage,
+        }),
+    };
+}
+export class ScheduledTaskRuntime {
+    botApi = null;
+    chatId = null;
+    initialized = false;
+    timersByTaskId = new Map();
+    runningTaskIds = new Set();
+    deliveryQueue = [];
+    flushInProgress = false;
+    async initialize(bot) {
+        this.botApi = bot.api;
+        this.chatId = config.telegram.allowedUserId;
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
+        await this.recoverTasksOnStartup();
+        await this.flushDeferredDeliveries();
+    }
+    registerTask(task) {
+        if (!this.initialized) {
+            return;
+        }
+        this.scheduleTask(task);
+    }
+    removeTask(taskId) {
+        const timer = this.timersByTaskId.get(taskId);
+        if (timer) {
+            clearTimeout(timer);
+            this.timersByTaskId.delete(taskId);
+        }
+        this.runningTaskIds.delete(taskId);
+        this.deliveryQueue = this.deliveryQueue.filter((delivery) => delivery.taskId !== taskId);
+    }
+    async flushDeferredDeliveries() {
+        if (this.flushInProgress ||
+            !this.botApi ||
+            this.chatId === null ||
+            foregroundSessionState.isBusy() ||
+            this.deliveryQueue.length === 0) {
+            return;
+        }
+        this.flushInProgress = true;
+        try {
+            while (this.deliveryQueue.length > 0 && !foregroundSessionState.isBusy()) {
+                const nextDelivery = this.deliveryQueue[0];
+                const sent = await this.sendDelivery(nextDelivery);
+                if (!sent) {
+                    break;
+                }
+                this.deliveryQueue.shift();
+            }
+        }
+        finally {
+            this.flushInProgress = false;
+        }
+    }
+    __resetForTests() {
+        for (const timer of this.timersByTaskId.values()) {
+            clearTimeout(timer);
+        }
+        this.botApi = null;
+        this.chatId = null;
+        this.initialized = false;
+        this.timersByTaskId.clear();
+        this.runningTaskIds.clear();
+        this.deliveryQueue = [];
+        this.flushInProgress = false;
+    }
+    async recoverTasksOnStartup() {
+        const tasks = listScheduledTasks();
+        if (tasks.length === 0) {
+            return;
+        }
+        const now = new Date();
+        let hasChanges = false;
+        const normalizedTasks = tasks.map((task) => {
+            const normalizedTask = { ...task, model: { ...task.model } };
+            if (normalizedTask.lastStatus === "running") {
+                normalizedTask.lastStatus = "error";
+                normalizedTask.lastError = RESTART_INTERRUPTED_ERROR;
+                hasChanges = true;
+            }
+            if (normalizedTask.kind === "cron") {
+                if (!normalizedTask.nextRunAt || Number.isNaN(Date.parse(normalizedTask.nextRunAt))) {
+                    try {
+                        normalizedTask.nextRunAt = computeNextRunAt(normalizedTask, now);
+                    }
+                    catch (error) {
+                        logger.error(`[ScheduledTaskRuntime] Failed to recover next run for cron task: id=${normalizedTask.id}`, error);
+                        normalizedTask.nextRunAt = null;
+                        normalizedTask.lastStatus = "error";
+                        normalizedTask.lastError =
+                            normalizedTask.lastError || "Failed to recover cron schedule.";
+                    }
+                    hasChanges = true;
+                }
+            }
+            else {
+                const runAtMs = Date.parse(normalizedTask.runAt);
+                if (Number.isNaN(runAtMs)) {
+                    normalizedTask.nextRunAt = null;
+                    normalizedTask.lastStatus = "error";
+                    normalizedTask.lastError =
+                        normalizedTask.lastError || "Invalid one-time task runAt value.";
+                    hasChanges = true;
+                }
+                else if (normalizedTask.nextRunAt === null && normalizedTask.lastStatus === "idle") {
+                    normalizedTask.nextRunAt = new Date(runAtMs).toISOString();
+                    hasChanges = true;
+                }
+            }
+            return normalizedTask;
+        });
+        if (hasChanges) {
+            await replaceScheduledTasks(normalizedTasks);
+        }
+        for (const task of normalizedTasks) {
+            this.scheduleTask(task);
+        }
+    }
+    scheduleTask(task) {
+        this.removeTaskTimer(task.id);
+        if (!task.nextRunAt) {
+            return;
+        }
+        const nextRunAtMs = Date.parse(task.nextRunAt);
+        if (Number.isNaN(nextRunAtMs)) {
+            logger.warn(`[ScheduledTaskRuntime] Invalid nextRunAt: id=${task.id}, value=${task.nextRunAt}`);
+            return;
+        }
+        const delayMs = nextRunAtMs - Date.now();
+        if (delayMs <= 0) {
+            this.startExecution(task.id);
+            return;
+        }
+        const timeoutMs = Math.min(delayMs, MAX_TIMER_DELAY_MS);
+        const timer = setTimeout(() => {
+            this.timersByTaskId.delete(task.id);
+            const currentTask = getScheduledTask(task.id);
+            if (!currentTask) {
+                return;
+            }
+            if (isTaskDue(currentTask)) {
+                this.startExecution(task.id);
+                return;
+            }
+            this.scheduleTask(currentTask);
+        }, timeoutMs);
+        this.timersByTaskId.set(task.id, timer);
+    }
+    removeTaskTimer(taskId) {
+        const timer = this.timersByTaskId.get(taskId);
+        if (!timer) {
+            return;
+        }
+        clearTimeout(timer);
+        this.timersByTaskId.delete(taskId);
+    }
+    startExecution(taskId) {
+        if (this.runningTaskIds.has(taskId)) {
+            return;
+        }
+        const task = getScheduledTask(taskId);
+        if (!task) {
+            this.removeTask(taskId);
+            return;
+        }
+        if (!isTaskDue(task)) {
+            this.scheduleTask(task);
+            return;
+        }
+        this.runningTaskIds.add(taskId);
+        safeBackgroundTask({
+            taskName: `scheduledTask.run.${taskId}`,
+            task: async () => {
+                await this.executeTask(taskId);
+            },
+            onError: (error) => {
+                logger.error(`[ScheduledTaskRuntime] Scheduled task run crashed: id=${taskId}`, error);
+                this.runningTaskIds.delete(taskId);
+            },
+        });
+    }
+    async executeTask(taskId) {
+        const taskSnapshot = getScheduledTask(taskId);
+        if (!taskSnapshot) {
+            this.removeTask(taskId);
+            this.runningTaskIds.delete(taskId);
+            return;
+        }
+        const startedAt = new Date().toISOString();
+        const runningTask = await updateScheduledTask(taskId, (task) => ({
+            ...task,
+            lastStatus: "running",
+            lastError: null,
+            lastRunAt: startedAt,
+            runCount: task.runCount + 1,
+        }));
+        if (!runningTask) {
+            this.removeTask(taskId);
+            this.runningTaskIds.delete(taskId);
+            return;
+        }
+        try {
+            const result = await executeScheduledTask(runningTask);
+            if (result.status === "success") {
+                await this.handleSuccessfulExecution(runningTask, result.finishedAt, result.resultText || "");
+            }
+            else {
+                await this.handleFailedExecution(runningTask, result.finishedAt, result.errorMessage || "Unknown error");
+            }
+        }
+        finally {
+            this.runningTaskIds.delete(taskId);
+        }
+    }
+    async handleSuccessfulExecution(task, finishedAt, resultText) {
+        const delivery = buildSuccessDelivery(task, finishedAt, resultText);
+        if (task.kind === "once") {
+            await removeScheduledTask(task.id);
+            this.removeTask(task.id);
+            await this.enqueueDelivery(delivery);
+            return;
+        }
+        let nextRunAt;
+        try {
+            nextRunAt = computeNextRunAt(task, new Date(finishedAt));
+        }
+        catch (error) {
+            logger.error(`[ScheduledTaskRuntime] Failed to compute next run after success: id=${task.id}`, error);
+            nextRunAt = null;
+        }
+        const updatedTask = await updateScheduledTask(task.id, (currentTask) => ({
+            ...currentTask,
+            lastStatus: "success",
+            lastError: null,
+            nextRunAt,
+        }));
+        if (updatedTask) {
+            this.scheduleTask(updatedTask);
+        }
+        await this.enqueueDelivery(delivery);
+    }
+    async handleFailedExecution(task, finishedAt, errorMessage) {
+        const delivery = buildErrorDelivery(task, finishedAt, errorMessage);
+        let nextRunAt = null;
+        if (task.kind === "cron") {
+            try {
+                nextRunAt = computeNextRunAt(task, new Date(finishedAt));
+            }
+            catch (error) {
+                logger.error(`[ScheduledTaskRuntime] Failed to compute next run after error: id=${task.id}`, error);
+            }
+        }
+        const updatedTask = await updateScheduledTask(task.id, (currentTask) => ({
+            ...currentTask,
+            lastStatus: "error",
+            lastError: errorMessage,
+            nextRunAt,
+        }));
+        if (updatedTask) {
+            this.scheduleTask(updatedTask);
+        }
+        await this.enqueueDelivery(delivery);
+    }
+    async enqueueDelivery(delivery) {
+        if (this.deliveryQueue.length === 0 &&
+            !this.flushInProgress &&
+            !foregroundSessionState.isBusy() &&
+            (await this.sendDelivery(delivery))) {
+            return;
+        }
+        this.deliveryQueue.push(delivery);
+    }
+    async sendDelivery(delivery) {
+        if (!this.botApi || this.chatId === null) {
+            return false;
+        }
+        try {
+            const messageParts = splitTelegramText(delivery.messageText);
+            for (const part of messageParts) {
+                await sendBotText({
+                    api: this.botApi,
+                    chatId: this.chatId,
+                    text: part,
+                    format: "raw",
+                });
+            }
+            return true;
+        }
+        catch (error) {
+            logger.error(`[ScheduledTaskRuntime] Failed to send delivery: id=${delivery.taskId}, status=${delivery.status}`, error);
+            return false;
+        }
+    }
+}
+export const scheduledTaskRuntime = new ScheduledTaskRuntime();