@grinev/opencode-telegram-bot 0.11.4 → 0.12.0

package/dist/i18n/ru.js

@@ -4,6 +4,8 @@ export const ru = {
     "cmd.description.stop": "Прервать текущее действие",
     "cmd.description.sessions": "Список сессий",
     "cmd.description.projects": "Список проектов",
+    "cmd.description.task": "Создать задачу по расписанию",
+    "cmd.description.tasklist": "Список задач по расписанию",
     "cmd.description.commands": "Пользовательские команды",
     "cmd.description.opencode_start": "Запустить OpenCode сервер",
     "cmd.description.opencode_stop": "Остановить OpenCode сервер",
@@ -30,7 +32,7 @@ export const ru = {
     "inline.cancelled_callback": "Отменено",
     "common.unknown": "неизвестна",
     "common.unknown_error": "неизвестная ошибка",
-    "start.welcome": "👋 Добро пожаловать в OpenCode Telegram Bot!\n\nИспользуйте команды:\n/projects — выбрать проект\n/sessions — список сессий\n/new — новая сессия\n/status — статус\n/help — справка\n\nРежим, модель и вариант выбираются кнопками внизу.",
+    "start.welcome": "👋 Добро пожаловать в OpenCode Telegram Bot!\n\nИспользуйте команды:\n/projects — выбрать проект\n/sessions — список сессий\n/new — новая сессия\n/task — задача по расписанию\n/tasklist — список задач по расписанию\n/status — статус\n/help — справка\n\nРежим, модель и вариант выбираются кнопками внизу.",
     "help.keyboard_hint": "💡 Режим, модель, вариант и действия с контекстом доступны через нижние кнопки клавиатуры.",
     "help.text": "📖 **Справка**\n\n/status - Проверить статус сервера\n/sessions - Список сессий\n/new - Создать новую сессию\n/help - Справка",
     "bot.thinking": "💭 Думаю...",
@@ -247,6 +249,41 @@ export const ru = {
     "rename.blocked.expected_name": "⚠️ Введите новое название текстом или нажмите Отмена в сообщении переименования.",
     "rename.blocked.command_not_allowed": "⚠️ Эта команда недоступна, пока ожидается новое название сессии.",
     "rename.button.cancel": "❌ Отмена",
+    "task.prompt.schedule": "⏰ Отправьте расписание задачи обычным языком.\n\nПримеры:\n- каждые 5 минут\n- каждый день в 17:00\n- завтра в 12:00",
+    "task.schedule_empty": "⚠️ Расписание не может быть пустым.",
+    "task.parse.in_progress": "⏳ Распознаю расписание...",
+    "task.parse_error": "🔴 Не удалось распознать расписание.\n\n{message}\n\nОтправьте период еще раз в более явном виде.",
+    "task.schedule_preview": "✅ Расписание распознано\n\nКак я понял: {summary}\n{cronLine}Часовой пояс: {timezone}\nТип: {kind}\nСледующий запуск: {nextRunAt}",
+    "task.schedule_preview.cron": "Cron: {cron}",
+    "task.prompt.body": "📝 Теперь отправьте текст задачи, которую нужно выполнять по расписанию.",
+    "task.prompt_empty": "⚠️ Текст задачи не может быть пустым.",
+    "task.created": "✅ Задача по расписанию создана\n\nЗадача: {description}\nПроект: {project}\nМодель: {model}\nРасписание: {schedule}\n{cronLine}Следующий запуск: {nextRunAt}",
+    "task.created.cron": "Cron: {cron}",
+    "task.button.retry_schedule": "🔁 Ввести период заново",
+    "task.button.cancel": "❌ Отмена",
+    "task.retry_schedule_callback": "Возвращаю ввод периода...",
+    "task.cancel_callback": "Отменяю...",
+    "task.cancelled": "❌ Создание задачи по расписанию отменено.",
+    "task.inactive_callback": "Этот сценарий создания задачи уже неактивен",
+    "task.inactive": "⚠️ Сценарий создания задачи неактивен. Запустите /task снова.",
+    "task.blocked.expected_input": "⚠️ Сначала завершите создание задачи по расписанию: отправьте текст или используйте кнопку в сообщении с расписанием.",
+    "task.blocked.command_not_allowed": "⚠️ Эта команда недоступна, пока идет создание задачи по расписанию.",
+    "task.limit_reached": "⚠️ Достигнут лимит задач ({limit}). Сначала удалите одну из существующих задач по расписанию.",
+    "task.schedule_too_frequent": "Повторяющееся расписание слишком частое. Минимально допустимый интервал - один запуск в 5 минут.",
+    "task.kind.cron": "повторяющаяся",
+    "task.kind.once": "однократная",
+    "task.run.success": "⏰ Задача по расписанию выполнена: {description}\n\n{result}",
+    "task.run.error": "🔴 Ошибка выполнения задачи по расписанию: {description}\n\nОшибка: {error}",
+    "tasklist.empty": "📭 Задач по расписанию пока нет.",
+    "tasklist.select": "Выберите задачу по расписанию:",
+    "tasklist.details": "⏰ Задача по расписанию\n\nЗадача: {prompt}\nПроект: {project}\nРасписание: {schedule}\n{cronLine}Часовой пояс: {timezone}\nСледующий запуск: {nextRunAt}\nПоследний запуск: {lastRunAt}\nКоличество запусков: {runCount}",
+    "tasklist.details.cron": "Cron: {cron}",
+    "tasklist.button.delete": "🗑 Удалить",
+    "tasklist.button.cancel": "❌ Отмена",
+    "tasklist.deleted_callback": "Удалено",
+    "tasklist.cancelled_callback": "Отменено",
+    "tasklist.inactive_callback": "Это меню задач по расписанию уже неактивно",
+    "tasklist.load_error": "🔴 Не удалось загрузить задачи по расписанию.",
     "commands.select": "Выберите команду OpenCode:",
     "commands.empty": "📭 Для этого проекта нет доступных команд OpenCode.",
     "commands.fetch_error": "🔴 Не удалось загрузить список команд OpenCode.",

package/dist/i18n/zh.js

@@ -4,6 +4,8 @@ export const zh = {
     "cmd.description.stop": "停止当前操作",
     "cmd.description.sessions": "列出会话",
     "cmd.description.projects": "列出项目",
+    "cmd.description.task": "创建定时任务",
+    "cmd.description.tasklist": "查看定时任务",
     "cmd.description.commands": "自定义命令",
     "cmd.description.opencode_start": "启动 OpenCode 服务器",
     "cmd.description.opencode_stop": "停止 OpenCode 服务器",
@@ -30,7 +32,7 @@ export const zh = {
     "inline.cancelled_callback": "已取消",
     "common.unknown": "未知",
     "common.unknown_error": "未知错误",
-    "start.welcome": "👋 欢迎使用 OpenCode Telegram Bot！\n\n可用命令：\n/projects — 选择项目\n/sessions — 会话列表\n/new — 新建会话\n/status — 状态\n/help — 帮助\n\n请使用底部按钮选择模式、模型和变体。",
+    "start.welcome": "👋 欢迎使用 OpenCode Telegram Bot！\n\n可用命令：\n/projects — 选择项目\n/sessions — 会话列表\n/new — 新建会话\n/task — 定时任务\n/tasklist — 定时任务列表\n/status — 状态\n/help — 帮助\n\n请使用底部按钮选择模式、模型和变体。",
     "help.keyboard_hint": "💡 代理模式、模型、变体和上下文操作请使用底部键盘按钮。",
     "help.text": "📖 **帮助**\n\n/status - 查看服务器状态\n/sessions - 会话列表\n/new - 创建新会话\n/help - 帮助",
     "bot.thinking": "💭 思考中...",
@@ -247,6 +249,41 @@ export const zh = {
     "rename.blocked.expected_name": "⚠️ 请以文本输入新会话名称，或在重命名消息中点击取消。",
     "rename.blocked.command_not_allowed": "⚠️ 重命名等待新名称期间不可用此命令。",
     "rename.button.cancel": "❌ 取消",
+    "task.prompt.schedule": "⏰ 请用自然语言发送任务的时间安排。\n\n示例：\n- 每 5 分钟\n- 每天 17:00\n- 明天 12:00",
+    "task.schedule_empty": "⚠️ 时间安排不能为空。",
+    "task.parse.in_progress": "⏳ 正在解析时间安排...",
+    "task.parse_error": "🔴 无法解析时间安排。\n\n{message}\n\n请用更清晰的方式重新发送。",
+    "task.schedule_preview": "✅ 时间安排已解析\n\n理解为：{summary}\n{cronLine}时区：{timezone}\n类型：{kind}\n下次运行：{nextRunAt}",
+    "task.schedule_preview.cron": "Cron: {cron}",
+    "task.prompt.body": "📝 现在发送机器人按此时间安排需要执行的内容。",
+    "task.prompt_empty": "⚠️ 任务文本不能为空。",
+    "task.created": "✅ 定时任务已创建\n\n任务：{description}\n项目：{project}\n模型：{model}\n时间安排：{schedule}\n{cronLine}下次运行：{nextRunAt}",
+    "task.created.cron": "Cron: {cron}",
+    "task.button.retry_schedule": "🔁 重新输入时间安排",
+    "task.button.cancel": "❌ 取消",
+    "task.retry_schedule_callback": "正在重新输入时间安排...",
+    "task.cancel_callback": "正在取消...",
+    "task.cancelled": "❌ 定时任务创建已取消。",
+    "task.inactive_callback": "这个定时任务流程已失效",
+    "task.inactive": "⚠️ 定时任务创建流程未激活。请重新运行 /task。",
+    "task.blocked.expected_input": "⚠️ 请先完成当前定时任务设置：发送文本，或使用时间安排消息中的按钮。",
+    "task.blocked.command_not_allowed": "⚠️ 定时任务创建进行中时，此命令不可用。",
+    "task.limit_reached": "⚠️ 已达到任务数量上限（{limit}）。请先删除一个现有定时任务。",
+    "task.schedule_too_frequent": "重复任务过于频繁。最小允许间隔为每 5 分钟一次。",
+    "task.kind.cron": "重复",
+    "task.kind.once": "一次性",
+    "task.run.success": "⏰ 定时任务已完成: {description}\n\n{result}",
+    "task.run.error": "🔴 定时任务执行失败: {description}\n\n错误: {error}",
+    "tasklist.empty": "📭 还没有定时任务。",
+    "tasklist.select": "请选择一个定时任务：",
+    "tasklist.details": "⏰ 定时任务\n\n任务：{prompt}\n项目：{project}\n计划：{schedule}\n{cronLine}时区：{timezone}\n下次运行：{nextRunAt}\n上次运行：{lastRunAt}\n运行次数：{runCount}",
+    "tasklist.details.cron": "Cron: {cron}",
+    "tasklist.button.delete": "🗑 删除",
+    "tasklist.button.cancel": "❌ 取消",
+    "tasklist.deleted_callback": "已删除",
+    "tasklist.cancelled_callback": "已取消",
+    "tasklist.inactive_callback": "此定时任务菜单已失效",
+    "tasklist.load_error": "🔴 无法加载定时任务。",
     "commands.select": "请选择一个 OpenCode 命令：",
     "commands.empty": "📭 当前项目没有可用的 OpenCode 命令。",
     "commands.fetch_error": "🔴 加载 OpenCode 命令失败。",

package/dist/interaction/cleanup.js

@@ -1,21 +1,29 @@
 import { permissionManager } from "../permission/manager.js";
 import { questionManager } from "../question/manager.js";
 import { renameManager } from "../rename/manager.js";
+import { taskCreationManager } from "../scheduled-task/creation-manager.js";
 import { interactionManager } from "./manager.js";
 import { logger } from "../utils/logger.js";
 export function clearAllInteractionState(reason) {
     const questionActive = questionManager.isActive();
     const permissionActive = permissionManager.isActive();
     const renameActive = renameManager.isWaitingForName();
+    const taskCreationActive = taskCreationManager.isActive();
     const interactionSnapshot = interactionManager.getSnapshot();
     questionManager.clear();
     permissionManager.clear();
     renameManager.clear();
+    taskCreationManager.clear();
     interactionManager.clear(reason);
-    const hasAnyActiveState = questionActive || permissionActive || renameActive || interactionSnapshot !== null;
+    const hasAnyActiveState = questionActive ||
+        permissionActive ||
+        renameActive ||
+        taskCreationActive ||
+        interactionSnapshot !== null;
     const message = `[InteractionCleanup] Cleared state: reason=${reason}, ` +
         `questionActive=${questionActive}, permissionActive=${permissionActive}, ` +
-        `renameActive=${renameActive}, interactionKind=${interactionSnapshot?.kind || "none"}`;
+        `renameActive=${renameActive}, taskCreationActive=${taskCreationActive}, ` +
+        `interactionKind=${interactionSnapshot?.kind || "none"}`;
     if (hasAnyActiveState) {
         logger.info(message);
         return;

package/dist/interaction/guard.js

@@ -62,6 +62,10 @@ function isAllowedRenameCancelCallback(ctx, state) {
         state.expectedInput === "text" &&
         ctx.callbackQuery?.data === "rename:cancel");
 }
+function isAllowedTaskCallback(ctx, state) {
+    return (state.kind === "task" &&
+        (ctx.callbackQuery?.data === "task:cancel" || ctx.callbackQuery?.data === "task:retry-schedule"));
+}
 export function resolveInteractionGuardDecision(ctx) {
     const state = interactionManager.getSnapshot();
     const { inputType, command } = classifyIncomingInput(ctx);
@@ -90,6 +94,9 @@ export function resolveInteractionGuardDecision(ctx) {
     if (inputType === "callback" && isAllowedRenameCancelCallback(ctx, state)) {
         return createAllowDecision(inputType, state, command);
     }
+    if (inputType === "callback" && isAllowedTaskCallback(ctx, state)) {
+        return createAllowDecision(inputType, state, command);
+    }
     if (state.expectedInput === inputType) {
         return createAllowDecision(inputType, state, command);
     }

package/dist/scheduled-task/creation-manager.js

@@ -0,0 +1,113 @@
+import { cloneParsedTaskSchedule, cloneScheduledTaskModel } from "./types.js";
+import { logger } from "../utils/logger.js";
+function cloneState(state) {
+    return {
+        ...state,
+        model: cloneScheduledTaskModel(state.model),
+        parsedSchedule: state.parsedSchedule ? cloneParsedTaskSchedule(state.parsedSchedule) : null,
+    };
+}
+class TaskCreationManager {
+    state = null;
+    start(projectId, projectWorktree, model) {
+        this.state = {
+            stage: "awaiting_schedule",
+            projectId,
+            projectWorktree,
+            model: cloneScheduledTaskModel(model),
+            scheduleText: null,
+            parsedSchedule: null,
+            scheduleRequestMessageId: null,
+            previewMessageId: null,
+            promptRequestMessageId: null,
+        };
+        logger.info(`[TaskCreationManager] Started task creation flow for project=${projectWorktree}`);
+        return cloneState(this.state);
+    }
+    isActive() {
+        return this.state !== null;
+    }
+    isWaitingForSchedule() {
+        return this.state?.stage === "awaiting_schedule";
+    }
+    isParsingSchedule() {
+        return this.state?.stage === "parsing_schedule";
+    }
+    isWaitingForPrompt() {
+        return this.state?.stage === "awaiting_prompt";
+    }
+    getState() {
+        return this.state ? cloneState(this.state) : null;
+    }
+    setParsedSchedule(scheduleText, parsedSchedule, previewMessageId) {
+        if (!this.state) {
+            return null;
+        }
+        this.state = {
+            ...this.state,
+            stage: "awaiting_prompt",
+            scheduleText,
+            parsedSchedule: cloneParsedTaskSchedule(parsedSchedule),
+            scheduleRequestMessageId: null,
+            previewMessageId,
+            promptRequestMessageId: null,
+        };
+        logger.info("[TaskCreationManager] Parsed schedule and switched flow to prompt input");
+        return cloneState(this.state);
+    }
+    markScheduleParsing() {
+        if (!this.state) {
+            return null;
+        }
+        this.state = {
+            ...this.state,
+            stage: "parsing_schedule",
+        };
+        logger.info("[TaskCreationManager] Schedule parsing started");
+        return cloneState(this.state);
+    }
+    setPromptRequestMessageId(messageId) {
+        if (!this.state) {
+            return null;
+        }
+        this.state = {
+            ...this.state,
+            promptRequestMessageId: messageId,
+        };
+        return cloneState(this.state);
+    }
+    setScheduleRequestMessageId(messageId) {
+        if (!this.state) {
+            return null;
+        }
+        this.state = {
+            ...this.state,
+            scheduleRequestMessageId: messageId,
+        };
+        return cloneState(this.state);
+    }
+    resetSchedule() {
+        if (!this.state) {
+            return null;
+        }
+        this.state = {
+            ...this.state,
+            stage: "awaiting_schedule",
+            scheduleText: null,
+            parsedSchedule: null,
+            scheduleRequestMessageId: null,
+            previewMessageId: null,
+            promptRequestMessageId: null,
+        };
+        logger.info("[TaskCreationManager] Reset task creation flow back to schedule input");
+        return cloneState(this.state);
+    }
+    clear() {
+        if (!this.state) {
+            return;
+        }
+        logger.debug("[TaskCreationManager] Clearing task creation state");
+        this.state = null;
+    }
+}
+export const taskCreationManager = new TaskCreationManager();

package/dist/scheduled-task/display.js

@@ -0,0 +1,239 @@
+const BADGE_DATE_LOCALE = "en-US";
+const WEEKDAY_LABELS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+const zonedDateTimeFormatterCache = new Map();
+const zonedYearFormatterCache = new Map();
+function getZonedDateTimeFormatter(timezone) {
+    const cached = zonedDateTimeFormatterCache.get(timezone);
+    if (cached) {
+        return cached;
+    }
+    const formatter = new Intl.DateTimeFormat(BADGE_DATE_LOCALE, {
+        timeZone: timezone,
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+        hourCycle: "h23",
+    });
+    zonedDateTimeFormatterCache.set(timezone, formatter);
+    return formatter;
+}
+function getZonedYearFormatter(timezone) {
+    const cached = zonedYearFormatterCache.get(timezone);
+    if (cached) {
+        return cached;
+    }
+    const formatter = new Intl.DateTimeFormat(BADGE_DATE_LOCALE, {
+        timeZone: timezone,
+        year: "numeric",
+    });
+    zonedYearFormatterCache.set(timezone, formatter);
+    return formatter;
+}
+function getDateTimePart(parts, type) {
+    return parts.find((part) => part.type === type)?.value ?? "";
+}
+function getZonedDateParts(date, timezone) {
+    const parts = getZonedDateTimeFormatter(timezone).formatToParts(date);
+    const year = Number.parseInt(getDateTimePart(parts, "year"), 10);
+    const month = getDateTimePart(parts, "month");
+    const day = Number.parseInt(getDateTimePart(parts, "day"), 10);
+    const hour = Number.parseInt(getDateTimePart(parts, "hour"), 10);
+    const minute = Number.parseInt(getDateTimePart(parts, "minute"), 10);
+    if (!Number.isInteger(year) ||
+        !month ||
+        !Number.isInteger(day) ||
+        !Number.isInteger(hour) ||
+        !Number.isInteger(minute)) {
+        return null;
+    }
+    return {
+        year,
+        month,
+        day,
+        hour,
+        minute,
+    };
+}
+function padNumber(value) {
+    return value.toString().padStart(2, "0");
+}
+function formatTime(hour, minute) {
+    return `${padNumber(hour)}:${padNumber(minute)}`;
+}
+function formatOnceTaskBadge(runAt, timezone) {
+    const runAtDate = new Date(runAt);
+    if (Number.isNaN(runAtDate.getTime())) {
+        return runAt;
+    }
+    const runAtParts = getZonedDateParts(runAtDate, timezone);
+    if (!runAtParts) {
+        return runAt;
+    }
+    const currentYear = getZonedYearFormatter(timezone).format(new Date());
+    const includeYear = currentYear !== String(runAtParts.year);
+    const dateLabel = includeYear
+        ? `${runAtParts.day} ${runAtParts.month} ${runAtParts.year}`
+        : `${runAtParts.day} ${runAtParts.month}`;
+    return `${dateLabel} ${formatTime(runAtParts.hour, runAtParts.minute)}`;
+}
+function parseCronParts(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        return null;
+    }
+    const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+    return {
+        minute,
+        hour,
+        dayOfMonth,
+        month,
+        dayOfWeek,
+    };
+}
+function parseExactNumber(field, min, max) {
+    const trimmedField = field.trim();
+    if (!/^\d+$/.test(trimmedField)) {
+        return null;
+    }
+    const value = Number.parseInt(trimmedField, 10);
+    if (!Number.isInteger(value) || value < min || value > max) {
+        return null;
+    }
+    return value;
+}
+function parseEveryStep(field, minStep, maxStep) {
+    const match = field.trim().match(/^\*\/(\d+)$/);
+    if (!match) {
+        return null;
+    }
+    const step = Number.parseInt(match[1], 10);
+    if (!Number.isInteger(step) || step < minStep || step > maxStep) {
+        return null;
+    }
+    return step;
+}
+function normalizeWeekdayValue(token) {
+    const normalized = token.trim().toLowerCase();
+    const aliases = {
+        sun: 0,
+        mon: 1,
+        tue: 2,
+        wed: 3,
+        thu: 4,
+        fri: 5,
+        sat: 6,
+    };
+    if (normalized in aliases) {
+        return aliases[normalized];
+    }
+    const numericValue = parseExactNumber(normalized, 0, 7);
+    if (numericValue === null) {
+        return null;
+    }
+    return numericValue === 7 ? 0 : numericValue;
+}
+function parseWeekdaySet(field) {
+    const values = new Set();
+    for (const token of field.split(",")) {
+        const trimmedToken = token.trim();
+        if (!trimmedToken || trimmedToken.includes("/")) {
+            return null;
+        }
+        if (trimmedToken.includes("-")) {
+            const [startRaw, endRaw] = trimmedToken.split("-");
+            const start = normalizeWeekdayValue(startRaw);
+            const end = normalizeWeekdayValue(endRaw);
+            if (start === null || end === null || start > end) {
+                return null;
+            }
+            for (let value = start; value <= end; value += 1) {
+                values.add(value);
+            }
+            continue;
+        }
+        const value = normalizeWeekdayValue(trimmedToken);
+        if (value === null) {
+            return null;
+        }
+        values.add(value);
+    }
+    return values;
+}
+function hasExactValues(values, expectedValues) {
+    return (values.size === expectedValues.length && expectedValues.every((value) => values.has(value)));
+}
+function formatCronTaskBadge(cron) {
+    const parts = parseCronParts(cron);
+    if (!parts) {
+        return "cron";
+    }
+    const minute = parseExactNumber(parts.minute, 0, 59);
+    const hour = parseExactNumber(parts.hour, 0, 23);
+    const everyMinuteStep = parseEveryStep(parts.minute, 1, 59);
+    const everyHourStep = parseEveryStep(parts.hour, 1, 23);
+    const monthIsWildcard = parts.month === "*";
+    const dayOfMonthIsWildcard = parts.dayOfMonth === "*";
+    const dayOfWeekIsWildcard = parts.dayOfWeek === "*";
+    if (everyMinuteStep !== null &&
+        parts.hour === "*" &&
+        monthIsWildcard &&
+        dayOfMonthIsWildcard &&
+        dayOfWeekIsWildcard) {
+        return `${everyMinuteStep}m`;
+    }
+    if (minute !== null &&
+        everyHourStep !== null &&
+        monthIsWildcard &&
+        dayOfMonthIsWildcard &&
+        dayOfWeekIsWildcard) {
+        return minute === 0 ? `${everyHourStep}h` : `${everyHourStep}h :${padNumber(minute)}`;
+    }
+    if (minute !== null &&
+        parts.hour === "*" &&
+        monthIsWildcard &&
+        dayOfMonthIsWildcard &&
+        dayOfWeekIsWildcard) {
+        return minute === 0 ? "hourly" : `hourly :${padNumber(minute)}`;
+    }
+    if (minute !== null &&
+        hour !== null &&
+        monthIsWildcard &&
+        dayOfMonthIsWildcard &&
+        dayOfWeekIsWildcard) {
+        return `daily ${formatTime(hour, minute)}`;
+    }
+    if (minute !== null && hour !== null && monthIsWildcard && dayOfMonthIsWildcard) {
+        const weekdayValues = parseWeekdaySet(parts.dayOfWeek);
+        if (!weekdayValues) {
+            return "cron";
+        }
+        if (hasExactValues(weekdayValues, [1, 2, 3, 4, 5])) {
+            return `weekdays ${formatTime(hour, minute)}`;
+        }
+        if (hasExactValues(weekdayValues, [0, 6])) {
+            return `weekends ${formatTime(hour, minute)}`;
+        }
+        if (weekdayValues.size === 1) {
+            const [weekday] = weekdayValues;
+            return `${WEEKDAY_LABELS[weekday]} ${formatTime(hour, minute)}`;
+        }
+    }
+    const dayOfMonth = parseExactNumber(parts.dayOfMonth, 1, 31);
+    if (minute !== null &&
+        hour !== null &&
+        dayOfMonth !== null &&
+        monthIsWildcard &&
+        dayOfWeekIsWildcard) {
+        return `monthly ${dayOfMonth} ${formatTime(hour, minute)}`;
+    }
+    return "cron";
+}
+export function formatTaskListBadge(task) {
+    if (task.kind === "once") {
+        return formatOnceTaskBadge(task.runAt, task.timezone);
+    }
+    return formatCronTaskBadge(task.cron);
+}

package/dist/scheduled-task/executor.js

@@ -0,0 +1,87 @@
+import { opencodeClient } from "../opencode/client.js";
+import { logger } from "../utils/logger.js";
+const SCHEDULED_TASK_AGENT = "build";
+const SCHEDULED_TASK_SESSION_TITLE = "Scheduled task run";
+function collectResponseText(parts) {
+    return parts
+        .filter((part) => part.type === "text" && typeof part.text === "string" && !part.ignored)
+        .map((part) => part.text)
+        .join("")
+        .trim();
+}
+function toErrorMessage(error) {
+    if (error instanceof Error && error.message.trim()) {
+        return error.message.trim();
+    }
+    if (typeof error === "string" && error.trim()) {
+        return error.trim();
+    }
+    return "Unknown scheduled task execution error";
+}
+export async function executeScheduledTask(task) {
+    const startedAt = new Date().toISOString();
+    let sessionId = null;
+    try {
+        const { data: session, error: createError } = await opencodeClient.session.create({
+            directory: task.projectWorktree,
+            title: SCHEDULED_TASK_SESSION_TITLE,
+        });
+        if (createError || !session) {
+            throw createError || new Error("Failed to create temporary scheduled task session");
+        }
+        sessionId = session.id;
+        const promptOptions = {
+            sessionID: session.id,
+            directory: session.directory,
+            parts: [{ type: "text", text: task.prompt }],
+            agent: SCHEDULED_TASK_AGENT,
+        };
+        if (task.model.providerID && task.model.modelID) {
+            promptOptions.model = {
+                providerID: task.model.providerID,
+                modelID: task.model.modelID,
+            };
+        }
+        if (task.model.variant) {
+            promptOptions.variant = task.model.variant;
+        }
+        const { data: response, error: promptError } = await opencodeClient.session.prompt(promptOptions);
+        if (promptError || !response) {
+            throw promptError || new Error("Scheduled task prompt execution failed");
+        }
+        const resultText = collectResponseText(response.parts);
+        if (!resultText) {
+            throw new Error("Scheduled task returned an empty assistant response");
+        }
+        return {
+            taskId: task.id,
+            status: "success",
+            startedAt,
+            finishedAt: new Date().toISOString(),
+            resultText,
+            errorMessage: null,
+        };
+    }
+    catch (error) {
+        const errorMessage = toErrorMessage(error);
+        logger.warn(`[ScheduledTaskExecutor] Task execution failed: id=${task.id}, message=${errorMessage}`);
+        return {
+            taskId: task.id,
+            status: "error",
+            startedAt,
+            finishedAt: new Date().toISOString(),
+            resultText: null,
+            errorMessage,
+        };
+    }
+    finally {
+        if (sessionId) {
+            try {
+                await opencodeClient.session.delete({ sessionID: sessionId });
+            }
+            catch (error) {
+                logger.warn(`[ScheduledTaskExecutor] Failed to delete temporary session: sessionId=${sessionId}`, error);
+            }
+        }
+    }
+}

package/dist/scheduled-task/foreground-state.js

@@ -0,0 +1,32 @@
+import { logger } from "../utils/logger.js";
+class ForegroundSessionState {
+    activeSessionIds = new Set();
+    markBusy(sessionId) {
+        if (!sessionId) {
+            return;
+        }
+        this.activeSessionIds.add(sessionId);
+        logger.debug(`[ScheduledTaskForeground] Marked session busy: session=${sessionId}, count=${this.activeSessionIds.size}`);
+    }
+    markIdle(sessionId) {
+        if (!sessionId) {
+            return;
+        }
+        this.activeSessionIds.delete(sessionId);
+        logger.debug(`[ScheduledTaskForeground] Marked session idle: session=${sessionId}, count=${this.activeSessionIds.size}`);
+    }
+    isBusy() {
+        return this.activeSessionIds.size > 0;
+    }
+    clearAll(reason) {
+        if (this.activeSessionIds.size === 0) {
+            return;
+        }
+        logger.info(`[ScheduledTaskForeground] Cleared foreground busy state: reason=${reason}, count=${this.activeSessionIds.size}`);
+        this.activeSessionIds.clear();
+    }
+    __resetForTests() {
+        this.activeSessionIds.clear();
+    }
+}
+export const foregroundSessionState = new ForegroundSessionState();