zardbot-telegram 1.0.0

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();

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);
+}