zardbot-telegram 1.0.0

package/dist/scheduled-task/runtime.js

@@ -0,0 +1,368 @@
+import { config } from "../config.js";
+import { escapePlainTextForTelegramMarkdownV2, formatSummaryWithMode, } from "../summary/formatter.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 MAX_TIMER_DELAY_MS = 2_147_483_647;
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+const TASK_DESCRIPTION_PREVIEW_LENGTH = 64;
+const RESTART_INTERRUPTED_ERROR = "Interrupted by bot restart during scheduled task execution.";
+function getScheduledTaskDeliveryFormat() {
+    return config.bot.messageFormatMode === "markdown" ? "markdown_v2" : "raw";
+}
+function buildScheduledTaskSuccessMessageParts(delivery) {
+    if (!delivery.resultText) {
+        return [delivery.notificationText];
+    }
+    if (config.bot.messageFormatMode !== "markdown") {
+        return formatSummaryWithMode(`${delivery.notificationText}\n\n${delivery.resultText}`, config.bot.messageFormatMode);
+    }
+    const header = escapePlainTextForTelegramMarkdownV2(delivery.notificationText);
+    const resultParts = formatSummaryWithMode(delivery.resultText, config.bot.messageFormatMode);
+    if (resultParts.length === 0) {
+        return [header];
+    }
+    const firstPart = `${header}\n\n${resultParts[0]}`;
+    if (firstPart.length <= TELEGRAM_MESSAGE_LIMIT) {
+        return [firstPart, ...resultParts.slice(1)];
+    }
+    return [header, ...resultParts];
+}
+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",
+        notificationText: t("task.run.success", {
+            description: normalizeTaskPrompt(task.prompt),
+        }),
+        resultText,
+    };
+}
+function buildErrorDelivery(task, runAt, errorMessage) {
+    return {
+        taskId: task.id,
+        scheduleSummary: task.scheduleSummary,
+        prompt: task.prompt,
+        runAt,
+        status: "error",
+        notificationText: 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 = delivery.status === "success"
+                ? buildScheduledTaskSuccessMessageParts(delivery)
+                : [delivery.notificationText];
+            const format = delivery.status === "success" ? getScheduledTaskDeliveryFormat() : "raw";
+            for (const part of messageParts) {
+                await sendBotText({
+                    api: this.botApi,
+                    chatId: this.chatId,
+                    text: part,
+                    format,
+                });
+            }
+            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();

package/dist/scheduled-task/schedule-parser.js

@@ -0,0 +1,169 @@
+import { opencodeClient } from "../opencode/client.js";
+import { logger } from "../utils/logger.js";
+const SCHEDULE_PARSE_SESSION_TITLE = "Scheduled task schedule parser";
+function getLocalTimezone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isValidIsoDatetime(value) {
+    return typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+function isValidTimezone(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        return false;
+    }
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: value }).format(new Date());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function extractJsonPayload(rawText) {
+    const trimmed = rawText.trim();
+    if (!trimmed) {
+        throw new Error("Empty schedule parser response");
+    }
+    const directCandidates = [trimmed];
+    const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fencedMatch?.[1]) {
+        directCandidates.unshift(fencedMatch[1].trim());
+    }
+    const firstBrace = trimmed.indexOf("{");
+    const lastBrace = trimmed.lastIndexOf("}");
+    if (firstBrace >= 0 && lastBrace > firstBrace) {
+        directCandidates.push(trimmed.slice(firstBrace, lastBrace + 1));
+    }
+    for (const candidate of directCandidates) {
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            // Try next candidate.
+        }
+    }
+    throw new Error("Schedule parser returned invalid JSON");
+}
+function validateParsedSchedule(value) {
+    if (!isRecord(value)) {
+        throw new Error("Schedule parser returned an invalid payload");
+    }
+    const kind = value.kind;
+    const summary = value.summary;
+    const timezone = value.timezone;
+    const nextRunAt = value.nextRunAt;
+    if (typeof summary !== "string" || !summary.trim()) {
+        throw new Error("Schedule summary is missing");
+    }
+    if (!isValidTimezone(timezone)) {
+        throw new Error("Schedule timezone is invalid");
+    }
+    if (!isValidIsoDatetime(nextRunAt)) {
+        throw new Error("Schedule nextRunAt is invalid");
+    }
+    if (kind === "cron") {
+        if (typeof value.cron !== "string" || !value.cron.trim()) {
+            throw new Error("Schedule cron expression is missing");
+        }
+        return {
+            kind,
+            cron: value.cron,
+            timezone,
+            summary: summary.trim(),
+            nextRunAt,
+        };
+    }
+    if (kind === "once") {
+        if (!isValidIsoDatetime(value.runAt)) {
+            throw new Error("Schedule runAt is invalid");
+        }
+        return {
+            kind,
+            runAt: value.runAt,
+            timezone,
+            summary: summary.trim(),
+            nextRunAt,
+        };
+    }
+    throw new Error("Schedule kind is invalid");
+}
+function parseSchedulePayload(rawText) {
+    const payload = extractJsonPayload(rawText);
+    if (isRecord(payload) && typeof payload.error === "string" && payload.error.trim()) {
+        throw new Error(payload.error.trim());
+    }
+    return validateParsedSchedule(payload);
+}
+function collectResponseText(parts) {
+    return parts
+        .filter((part) => part.type === "text" && typeof part.text === "string" && !part.ignored)
+        .map((part) => part.text)
+        .join("")
+        .trim();
+}
+function buildSchedulePrompt(scheduleText, timezone) {
+    const now = new Date().toISOString();
+    return [
+        "Parse the following natural-language task schedule and return JSON only.",
+        "Do not use markdown, explanations, code fences, or any extra text.",
+        `Assume the default timezone is ${timezone}.`,
+        `Current date/time reference: ${now}.`,
+        "Supported interpretations include recurring schedules and one-time schedules.",
+        "If parsing succeeds, return exactly one JSON object with keys: kind, timezone, summary, nextRunAt, and either cron or runAt.",
+        'Use kind="cron" for recurring schedules and kind="once" for one-time schedules.',
+        "summary must be a concise human-readable description in the same language as the input.",
+        "nextRunAt and runAt must be ISO 8601 timestamps with timezone offset.",
+        'If parsing fails or input is ambiguous, return {"error":"short explanation"}.',
+        "",
+        `Input: ${scheduleText}`,
+    ].join("\n");
+}
+export async function parseTaskSchedule(scheduleText, directory) {
+    const trimmedScheduleText = scheduleText.trim();
+    if (!trimmedScheduleText) {
+        throw new Error("Schedule text is empty");
+    }
+    const trimmedDirectory = directory.trim();
+    if (!trimmedDirectory) {
+        throw new Error("Schedule parser directory is empty");
+    }
+    const timezone = getLocalTimezone();
+    let sessionId = null;
+    try {
+        const { data: session, error: createError } = await opencodeClient.session.create({
+            directory: trimmedDirectory,
+            title: SCHEDULE_PARSE_SESSION_TITLE,
+        });
+        if (createError || !session) {
+            throw createError || new Error("Failed to create temporary schedule parser session");
+        }
+        sessionId = session.id;
+        const { data: response, error: promptError } = await opencodeClient.session.prompt({
+            sessionID: session.id,
+            directory: session.directory,
+            system: "You are a schedule parser. Your only job is to convert user schedule text into strict JSON output.",
+            parts: [{ type: "text", text: buildSchedulePrompt(trimmedScheduleText, timezone) }],
+        });
+        if (promptError || !response) {
+            throw promptError || new Error("Failed to parse schedule");
+        }
+        const responseText = collectResponseText(response.parts);
+        if (!responseText) {
+            throw new Error("Schedule parser returned an empty response");
+        }
+        return parseSchedulePayload(responseText);
+    }
+    finally {
+        if (sessionId) {
+            try {
+                await opencodeClient.session.delete({ sessionID: sessionId });
+            }
+            catch (error) {
+                logger.warn(`[ScheduledTaskScheduleParser] Failed to delete temporary session: sessionId=${sessionId}`, error);
+            }
+        }
+    }
+}

package/dist/scheduled-task/store.js

@@ -0,0 +1,65 @@
+import { getScheduledTasks, setScheduledTasks } from "../settings/manager.js";
+import { logger } from "../utils/logger.js";
+import { cloneScheduledTask } from "./types.js";
+let scheduledTaskMutationQueue = Promise.resolve();
+async function mutateScheduledTasks(mutator) {
+    const runMutation = async () => {
+        const currentTasks = listScheduledTasks();
+        const { tasks, result } = await mutator(currentTasks);
+        await setScheduledTasks(tasks.map((task) => cloneScheduledTask(task)));
+        return result;
+    };
+    const mutationPromise = scheduledTaskMutationQueue.then(runMutation, runMutation);
+    scheduledTaskMutationQueue = mutationPromise.catch(() => undefined);
+    return mutationPromise;
+}
+export function listScheduledTasks() {
+    return getScheduledTasks().map((task) => cloneScheduledTask(task));
+}
+export function getScheduledTask(taskId) {
+    const task = listScheduledTasks().find((item) => item.id === taskId);
+    return task ? cloneScheduledTask(task) : null;
+}
+export async function addScheduledTask(task) {
+    await mutateScheduledTasks((tasks) => ({
+        tasks: [...tasks, cloneScheduledTask(task)],
+        result: undefined,
+    }));
+    logger.info(`[ScheduledTaskStore] Added scheduled task: id=${task.id}, kind=${task.kind}`);
+}
+export async function replaceScheduledTasks(tasks) {
+    await mutateScheduledTasks(() => ({
+        tasks: tasks.map((task) => cloneScheduledTask(task)),
+        result: undefined,
+    }));
+    logger.info(`[ScheduledTaskStore] Replaced scheduled task collection: count=${tasks.length}`);
+}
+export async function removeScheduledTask(taskId) {
+    const removed = await mutateScheduledTasks((tasks) => {
+        const nextTasks = tasks.filter((task) => task.id !== taskId);
+        return {
+            tasks: nextTasks,
+            result: nextTasks.length !== tasks.length,
+        };
+    });
+    if (!removed) {
+        return false;
+    }
+    logger.info(`[ScheduledTaskStore] Removed scheduled task: id=${taskId}`);
+    return true;
+}
+export async function updateScheduledTask(taskId, updater) {
+    return mutateScheduledTasks((tasks) => {
+        const index = tasks.findIndex((task) => task.id === taskId);
+        if (index < 0) {
+            return { tasks, result: null };
+        }
+        const nextTask = cloneScheduledTask(updater(cloneScheduledTask(tasks[index])));
+        const nextTasks = [...tasks];
+        nextTasks[index] = nextTask;
+        return {
+            tasks: nextTasks,
+            result: cloneScheduledTask(nextTask),
+        };
+    });
+}

package/dist/scheduled-task/types.js

@@ -0,0 +1,19 @@
+export function createScheduledTaskModel(model) {
+    return {
+        providerID: model.providerID,
+        modelID: model.modelID,
+        variant: model.variant ?? null,
+    };
+}
+export function cloneParsedTaskSchedule(schedule) {
+    return { ...schedule };
+}
+export function cloneScheduledTaskModel(model) {
+    return { ...model };
+}
+export function cloneScheduledTask(task) {
+    return {
+        ...task,
+        model: cloneScheduledTaskModel(task.model),
+    };
+}