talon-agent 1.12.0 → 1.34.0

package/src/frontend/telegram/actions/media.ts

@@ -0,0 +1,224 @@
+/**
+ * Media actions — sending files/photos/videos/animations/voice/audio,
+ * stickers, polls, locations, contacts, and dice.
+ */
+
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename } from "node:path";
+import { expandFsPath } from "../../../util/fs-path.js";
+import { markdownToTelegramHtml } from "../formatting.js";
+import { withRetry } from "../../../core/engine/gateway.js";
+import { resolveStickerByEmoji } from "../sticker-library.js";
+import { replyParams } from "./shared.js";
+import type { TelegramActionHandlers } from "./types.js";
+
+const sendMediaFile: TelegramActionHandlers[string] = async (
+  body,
+  chatId,
+  { bot, InputFileClass, gateway },
+) => {
+  // Routed for send_file / send_photo / send_video / send_animation /
+  // send_voice / send_audio — branch on the action name in the body.
+  const action = String(body.action);
+  const caption = body.caption
+    ? markdownToTelegramHtml(String(body.caption))
+    : undefined;
+  const captionParseMode = caption ? ("HTML" as const) : undefined;
+  gateway.incrementMessages(chatId);
+  // Three media sources, in priority order: a public URL or a Telegram
+  // file_id (both passed to the Bot API as a plain string — Telegram
+  // fetches/reuses server-side, no local bytes involved), else a
+  // workspace file path uploaded as multipart.
+  const remote = body.url ?? body.file_id;
+  let file: string | import("grammy").InputFile;
+  if (remote) {
+    file = String(remote);
+  } else {
+    // Fail with guidance the model can act on, not a raw ENOENT: a
+    // mistyped path is the most common media-send error, and naming
+    // the alternatives (url / file_id) teaches the recovery path.
+    if (!body.file_path)
+      return {
+        ok: false,
+        error: `${action}: provide file_path (workspace file), url (public), or file_id (seen in chat)`,
+      };
+    const filePath = expandFsPath(String(body.file_path));
+    if (!existsSync(filePath))
+      return {
+        ok: false,
+        error: `File not found: ${filePath} — check the workspace path, or send by url/file_id instead`,
+      };
+    const stat = statSync(filePath);
+    if (stat.size > 49 * 1024 * 1024)
+      return { ok: false, error: "File too large (max 49MB)" };
+    const data = readFileSync(filePath);
+    file = new InputFileClass(data, basename(filePath));
+  }
+  const rp = replyParams(body);
+  let sent;
+  switch (action) {
+    case "send_file":
+      sent = await withRetry(() =>
+        bot.api.sendDocument(chatId, file, {
+          caption,
+          parse_mode: captionParseMode,
+          reply_parameters: rp,
+        }),
+      );
+      break;
+    case "send_photo":
+      sent = await withRetry(() =>
+        bot.api.sendPhoto(chatId, file, {
+          caption,
+          parse_mode: captionParseMode,
+          reply_parameters: rp,
+        }),
+      );
+      break;
+    case "send_video":
+      sent = await withRetry(() =>
+        bot.api.sendVideo(chatId, file, {
+          caption,
+          parse_mode: captionParseMode,
+          reply_parameters: rp,
+        }),
+      );
+      break;
+    case "send_animation":
+      sent = await withRetry(() =>
+        bot.api.sendAnimation(chatId, file, {
+          caption,
+          parse_mode: captionParseMode,
+          reply_parameters: rp,
+        }),
+      );
+      break;
+    case "send_audio":
+      sent = await withRetry(() =>
+        bot.api.sendAudio(chatId, file, {
+          caption,
+          parse_mode: captionParseMode,
+          reply_parameters: rp,
+          title: body.title as string | undefined,
+          performer: body.performer as string | undefined,
+        }),
+      );
+      break;
+    default:
+      sent = await withRetry(() =>
+        bot.api.sendVoice(chatId, file, {
+          caption,
+          parse_mode: captionParseMode,
+          reply_parameters: rp,
+        }),
+      );
+      break;
+  }
+  return { ok: true, message_id: sent.message_id };
+};
+
+export const mediaHandlers: TelegramActionHandlers = {
+  send_file: sendMediaFile,
+  send_photo: sendMediaFile,
+  send_video: sendMediaFile,
+  send_animation: sendMediaFile,
+  send_voice: sendMediaFile,
+  send_audio: sendMediaFile,
+
+  send_sticker: async (body, chatId, { bot, gateway }) => {
+    // Three addressing modes: a concrete file_id, a public URL of a
+    // .webp (Telegram fetches it server-side, like other media), or an
+    // emoji resolved against the saved sticker library (optionally
+    // pinned to one pack via set_name) — the low-friction path the
+    // prompt teaches.
+    let fileId = body.file_id
+      ? String(body.file_id)
+      : body.url
+        ? String(body.url)
+        : "";
+    if (!fileId && body.emoji) {
+      const resolved = await resolveStickerByEmoji(
+        bot,
+        String(body.emoji),
+        body.set_name ? String(body.set_name) : undefined,
+      );
+      if (!resolved) {
+        return {
+          ok: false,
+          error: `No saved sticker matches ${String(body.emoji)}${body.set_name ? ` in pack "${String(body.set_name)}"` : ""} — check the sticker library, or save a pack with save_sticker_pack.`,
+        };
+      }
+      fileId = resolved.fileId;
+    }
+    if (!fileId)
+      return { ok: false, error: "Required: file_id, url, or emoji" };
+    gateway.incrementMessages(chatId);
+    const sent = await bot.api.sendSticker(chatId, fileId, {
+      reply_parameters: replyParams(body),
+    });
+    return { ok: true, message_id: sent.message_id };
+  },
+
+  send_poll: async (body, chatId, { bot, gateway }) => {
+    gateway.incrementMessages(chatId);
+    const sent = await bot.api.sendPoll(
+      chatId,
+      String(body.question ?? ""),
+      ((body.options as string[]) ?? []).map((o) => ({ text: o })),
+      {
+        is_anonymous: body.is_anonymous as boolean | undefined,
+        allows_multiple_answers: body.allows_multiple_answers as
+          boolean | undefined,
+        type: body.type as "regular" | "quiz" | undefined,
+        correct_option_ids:
+          body.correct_option_id != null
+            ? [body.correct_option_id as number]
+            : undefined,
+        explanation: body.explanation as string | undefined,
+        reply_parameters: replyParams(body),
+      },
+    );
+    return { ok: true, message_id: sent.message_id };
+  },
+
+  send_location: async (body, chatId, { bot, gateway }) => {
+    gateway.incrementMessages(chatId);
+    const sent = await bot.api.sendLocation(
+      chatId,
+      Number(body.latitude),
+      Number(body.longitude),
+      { reply_parameters: replyParams(body) },
+    );
+    return { ok: true, message_id: sent.message_id };
+  },
+
+  send_contact: async (body, chatId, { bot, gateway }) => {
+    gateway.incrementMessages(chatId);
+    const sent = await bot.api.sendContact(
+      chatId,
+      String(body.phone_number),
+      String(body.first_name),
+      {
+        last_name: body.last_name as string | undefined,
+        reply_parameters: replyParams(body),
+      },
+    );
+    return { ok: true, message_id: sent.message_id };
+  },
+
+  send_dice: async (body, chatId, { bot, gateway }) => {
+    gateway.incrementMessages(chatId);
+    const sent = await bot.api.sendDice(
+      chatId,
+      (body.emoji as string) || "🎲",
+      {
+        reply_parameters: replyParams(body),
+      },
+    );
+    return {
+      ok: true,
+      message_id: sent.message_id,
+      value: sent.dice?.value,
+    };
+  },
+};

package/src/frontend/telegram/actions/messaging.ts

@@ -0,0 +1,295 @@
+/**
+ * Messaging actions — send/reply/edit/delete/pin/forward/copy/react,
+ * inline-button messages, chat actions, and scheduled messages.
+ */
+
+import type { Bot } from "grammy";
+import { markdownToTelegramHtml } from "../formatting.js";
+import { withRetry } from "../../../core/engine/gateway.js";
+import { log, logError, logWarn } from "../../../util/log.js";
+import {
+  saveScheduled,
+  deleteScheduled,
+  listScheduled,
+  listScheduledForChat,
+  MAX_OVERDUE_MS,
+  type ScheduledMessage,
+} from "../../../storage/scheduled-store.js";
+import { sendText, toPositiveId } from "./shared.js";
+import { TELEGRAM_MAX_TEXT, type TelegramActionHandlers } from "./types.js";
+
+// ── Scheduled sends (persistent) ─────────────────────────────────────────────
+
+/** Longest schedulable delay: 24h. Timers re-arm from the store on boot. */
+const MAX_DELAY_SEC = 24 * 60 * 60;
+
+/** Deliver one scheduled entry (shared by the live timer and restore). */
+async function fireScheduled(bot: Bot, entry: ScheduledMessage): Promise<void> {
+  const chatId = Number(entry.chatId);
+  if (entry.rows) {
+    const keyboard = entry.rows.map((row) =>
+      row.map((btn) =>
+        btn.url
+          ? { text: btn.text, url: btn.url }
+          : { text: btn.text, callback_data: btn.callback_data ?? btn.text },
+      ),
+    );
+    await bot.api.sendMessage(chatId, markdownToTelegramHtml(entry.text), {
+      parse_mode: "HTML",
+      reply_markup: { inline_keyboard: keyboard },
+      reply_parameters: entry.replyTo
+        ? { message_id: entry.replyTo }
+        : undefined,
+    });
+  } else {
+    await sendText(bot, chatId, entry.text, entry.replyTo);
+  }
+}
+
+/** Arm a timer for a stored entry; fires, then cleans up store + map. */
+function armScheduled(
+  bot: Bot,
+  entry: ScheduledMessage,
+  timers: Map<string, ReturnType<typeof setTimeout>>,
+): void {
+  const delayMs = Math.max(0, entry.fireAt - Date.now());
+  const timer = setTimeout(async () => {
+    try {
+      await fireScheduled(bot, entry);
+    } catch (err) {
+      logError("bot", `Scheduled message failed (chat=${entry.chatId})`, err);
+    }
+    deleteScheduled(entry.id);
+    timers.delete(entry.id);
+  }, delayMs);
+  timers.set(entry.id, timer);
+}
+
+/**
+ * Re-arm persisted scheduled sends after a restart. Called once when
+ * the action handler is created. Overdue entries fire immediately —
+ * late beats never — unless they are stale past MAX_OVERDUE_MS, which
+ * drops them (a day-late reminder is noise, not delivery).
+ */
+export function restoreScheduledMessages(
+  bot: Bot,
+  timers: Map<string, ReturnType<typeof setTimeout>>,
+): void {
+  const entries = listScheduled("telegram");
+  if (entries.length === 0) return;
+  let restored = 0;
+  let dropped = 0;
+  for (const entry of entries) {
+    if (Date.now() - entry.fireAt > MAX_OVERDUE_MS) {
+      deleteScheduled(entry.id);
+      dropped++;
+      continue;
+    }
+    armScheduled(bot, entry, timers);
+    restored++;
+  }
+  log(
+    "bot",
+    `Restored ${restored} scheduled message(s) from store${dropped > 0 ? `, dropped ${dropped} stale` : ""}`,
+  );
+}
+
+export const messagingHandlers: TelegramActionHandlers = {
+  send_message: async (body, chatId, { bot, gateway }) => {
+    const text = String(body.text ?? "");
+    const replyTo = toPositiveId(body.reply_to_message_id);
+    gateway.incrementMessages(chatId);
+    const msgId = await withRetry(() => sendText(bot, chatId, text, replyTo));
+    return { ok: true, message_id: msgId };
+  },
+
+  reply_to: async (body, chatId, { bot, gateway }) => {
+    const msgId = Number(body.message_id);
+    gateway.incrementMessages(chatId);
+    const sentId = await withRetry(() =>
+      sendText(bot, chatId, String(body.text ?? ""), msgId),
+    );
+    return { ok: true, message_id: sentId };
+  },
+
+  react: async (body, chatId, { bot, gateway }) => {
+    gateway.incrementMessages(chatId);
+    const emoji = String(body.emoji ?? "👍");
+    try {
+      await withRetry(() =>
+        bot.api.setMessageReaction(chatId, Number(body.message_id), [
+          { type: "emoji", emoji: emoji as "👍" },
+        ]),
+      );
+    } catch (err) {
+      logWarn(
+        "bot",
+        `Custom emoji reaction failed, falling back to 👍: ${err instanceof Error ? err.message : err}`,
+      );
+      try {
+        await bot.api.setMessageReaction(chatId, Number(body.message_id), [
+          { type: "emoji", emoji: "👍" },
+        ]);
+      } catch (e) {
+        return {
+          ok: false,
+          error: `Reaction failed: ${e instanceof Error ? e.message : e}`,
+        };
+      }
+    }
+    return { ok: true };
+  },
+
+  edit_message: async (body, chatId, { bot }) => {
+    const text = String(body.text ?? "");
+    if (text.length > TELEGRAM_MAX_TEXT)
+      return {
+        ok: false,
+        error: `Text too long (max ${TELEGRAM_MAX_TEXT})`,
+      };
+    const html = markdownToTelegramHtml(text);
+    await withRetry(async () => {
+      try {
+        await bot.api.editMessageText(chatId, Number(body.message_id), html, {
+          parse_mode: "HTML",
+        });
+      } catch {
+        await bot.api.editMessageText(chatId, Number(body.message_id), text);
+      }
+    });
+    return { ok: true };
+  },
+
+  delete_message: async (body, chatId, { bot }) => {
+    await bot.api.deleteMessage(chatId, Number(body.message_id));
+    return { ok: true };
+  },
+
+  pin_message: async (body, chatId, { bot }) => {
+    await bot.api.pinChatMessage(chatId, Number(body.message_id));
+    return { ok: true };
+  },
+
+  unpin_message: async (body, chatId, { bot }) => {
+    await bot.api.unpinChatMessage(
+      chatId,
+      body.message_id ? Number(body.message_id) : undefined,
+    );
+    return { ok: true };
+  },
+
+  forward_message: async (body, chatId, { bot }) => {
+    if (body.to_chat_id && Number(body.to_chat_id) !== chatId)
+      return { ok: false, error: "Cross-chat forwarding not allowed." };
+    const sent = await bot.api.forwardMessage(
+      chatId,
+      chatId,
+      Number(body.message_id),
+    );
+    return { ok: true, message_id: sent.message_id };
+  },
+
+  copy_message: async (body, chatId, { bot }) => {
+    const sent = await bot.api.copyMessage(
+      chatId,
+      chatId,
+      Number(body.message_id),
+    );
+    return { ok: true, message_id: sent.message_id };
+  },
+
+  send_chat_action: async (body, chatId, { bot }) => {
+    await bot.api.sendChatAction(
+      chatId,
+      String(body.chat_action ?? "typing") as "typing",
+    );
+    return { ok: true };
+  },
+
+  send_message_with_buttons: async (body, chatId, { bot, gateway }) => {
+    const text = String(body.text ?? "");
+    if (text.length > TELEGRAM_MAX_TEXT)
+      return { ok: false, error: `Text too long` };
+    const html = markdownToTelegramHtml(text);
+    const rows = body.rows as Array<
+      Array<{ text: string; url?: string; callback_data?: string }>
+    >;
+    gateway.incrementMessages(chatId);
+    const keyboard = rows.map((row) =>
+      row.map((btn) =>
+        btn.url
+          ? { text: btn.text, url: btn.url }
+          : {
+              text: btn.text,
+              callback_data: btn.callback_data ?? btn.text,
+            },
+      ),
+    );
+    try {
+      const sent = await bot.api.sendMessage(chatId, html, {
+        parse_mode: "HTML",
+        reply_markup: { inline_keyboard: keyboard },
+      });
+      return { ok: true, message_id: sent.message_id };
+    } catch {
+      const sent = await bot.api.sendMessage(chatId, text, {
+        reply_markup: { inline_keyboard: keyboard },
+      });
+      return { ok: true, message_id: sent.message_id };
+    }
+  },
+
+  schedule_message: (body, chatId, { bot, scheduledMessages }) => {
+    const text = String(body.text ?? "");
+    const replyTo = toPositiveId(body.reply_to_message_id);
+    const rows = body.rows as ScheduledMessage["rows"];
+    const delaySec = Math.max(
+      1,
+      Math.min(MAX_DELAY_SEC, Number(body.delay_seconds ?? 60)),
+    );
+    const entry: ScheduledMessage = {
+      id: `sched_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      frontend: "telegram",
+      chatId: String(chatId),
+      text,
+      fireAt: Date.now() + delaySec * 1000,
+      createdAt: Date.now(),
+      replyTo,
+      rows,
+    };
+    // Persist before arming: if we crash between the two, the restore
+    // path delivers it; the reverse order could lose it forever.
+    saveScheduled(entry);
+    armScheduled(bot, entry, scheduledMessages);
+    return { ok: true, schedule_id: entry.id, delay_seconds: delaySec };
+  },
+
+  cancel_scheduled: (body, _chatId, { scheduledMessages }) => {
+    const id = String(body.schedule_id ?? "");
+    const timer = scheduledMessages.get(id);
+    if (timer) {
+      clearTimeout(timer);
+      scheduledMessages.delete(id);
+    }
+    // The store is the source of truth — an entry can exist without a
+    // live timer (scheduled before a restart, not yet re-armed here).
+    const existed = deleteScheduled(id) || Boolean(timer);
+    return existed
+      ? { ok: true, cancelled: true }
+      : { ok: false, error: "Schedule not found" };
+  },
+
+  list_scheduled: (body, chatId) => {
+    const pending = listScheduledForChat("telegram", String(chatId)).map(
+      (e) => ({
+        schedule_id: e.id,
+        fires_in_seconds: Math.max(
+          0,
+          Math.round((e.fireAt - Date.now()) / 1000),
+        ),
+        text: e.text.length > 200 ? `${e.text.slice(0, 200)}…` : e.text,
+      }),
+    );
+    return { ok: true, scheduled: pending, count: pending.length };
+  },
+};

package/src/frontend/telegram/actions/shared.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared helpers for Telegram action handlers: reply-parameter extraction and
+ * the HTML-with-plain-fallback text sender.
+ */
+
+import type { Bot } from "grammy";
+import { markdownToTelegramHtml } from "../formatting.js";
+import { logWarn } from "../../../util/log.js";
+import { TELEGRAM_MAX_TEXT } from "./types.js";
+
+export function replyParams(
+  body: Record<string, unknown>,
+): { message_id: number } | undefined {
+  const replyTo = toPositiveId(body.reply_to ?? body.reply_to_message_id);
+  return replyTo !== undefined ? { message_id: replyTo } : undefined;
+}
+
+/**
+ * Telegram/GramJS APIs expect numeric IDs. `snowflakeOrIdSchema` normalizes IDs
+ * to digit-strings (so 17-19 digit Discord snowflakes survive validation), so a
+ * Telegram message/reply/offset ID can arrive here as a string. Coerce it back
+ * to a positive integer: Telegram IDs are well within 2^53, so this is lossless.
+ * Returns undefined for missing / non-positive / non-integer values.
+ */
+export function toPositiveId(v: unknown): number | undefined {
+  const n = typeof v === "number" ? v : typeof v === "string" ? Number(v) : NaN;
+  return Number.isInteger(n) && n > 0 ? n : undefined;
+}
+
+export async function sendText(
+  bot: Bot,
+  chatId: number,
+  text: string,
+  replyTo?: number,
+): Promise<number> {
+  if (text.length > TELEGRAM_MAX_TEXT) {
+    throw new Error(
+      `Message too long (${text.length} chars, max ${TELEGRAM_MAX_TEXT}).`,
+    );
+  }
+  const html = markdownToTelegramHtml(text);
+  try {
+    const sent = await bot.api.sendMessage(chatId, html, {
+      parse_mode: "HTML",
+      reply_parameters: replyTo ? { message_id: replyTo } : undefined,
+    });
+    return sent.message_id;
+  } catch (err) {
+    logWarn(
+      "bot",
+      `sendText with parse_mode=HTML failed; retrying without parse_mode (chat=${chatId}): ${err instanceof Error ? err.message : err}`,
+    );
+    const sent = await bot.api.sendMessage(chatId, text, {
+      reply_parameters: replyTo ? { message_id: replyTo } : undefined,
+    });
+    return sent.message_id;
+  }
+}

package/src/frontend/telegram/actions/types.ts

@@ -0,0 +1,31 @@
+/**
+ * Telegram action-handler types.
+ *
+ * Each domain module exports a `TelegramActionHandlers` map keyed by action
+ * name. Handlers receive the request body, the numeric chat id, and a shared
+ * `TelegramActionContext` carrying the bound bot, the InputFile constructor,
+ * the bot token, the gateway, and the per-handler `scheduledMessages` timers.
+ */
+
+import type { Bot, InputFile as GrammyInputFile } from "grammy";
+import type { Gateway } from "../../../core/engine/gateway.js";
+import type { ActionResult } from "../../../core/types.js";
+
+export interface TelegramActionContext {
+  bot: Bot;
+  InputFileClass: typeof GrammyInputFile;
+  botToken: string;
+  gateway: Gateway;
+  /** Active scheduled-message timers, keyed by schedule id (for cancellation). */
+  scheduledMessages: Map<string, ReturnType<typeof setTimeout>>;
+}
+
+export type TelegramActionHandler = (
+  body: Record<string, unknown>,
+  chatId: number,
+  ctx: TelegramActionContext,
+) => Promise<ActionResult | null> | ActionResult | null;
+
+export type TelegramActionHandlers = Record<string, TelegramActionHandler>;
+
+export const TELEGRAM_MAX_TEXT = 4096;

package/src/frontend/telegram/admin.ts

@@ -6,18 +6,20 @@ import type { Bot, Context } from "grammy";
 import { readFileSync } from "node:fs";
 import type { TalonConfig } from "../../util/config.js";
 import { files, dirs } from "../../util/paths.js";
+import { tailFile } from "../../util/tail-file.js";
 import { escapeHtml } from "./formatting.js";
 import { resetSession, getAllSessions } from "../../storage/sessions.js";
 import { clearHistory } from "../../storage/history.js";
 import { getChatSettings } from "../../storage/chat-settings.js";
 import {
   getAllCronJobs,
-  validateCronExpression,
+  describeSchedule,
+  nextRunAt,
 } from "../../storage/cron-store.js";
-import { getActiveCount } from "../../core/dispatcher.js";
-import { getPulseStatus } from "../../core/pulse.js";
+import { getActiveCount } from "../../core/engine/dispatcher.js";
+import { getPulseStatus } from "../../core/background/pulse.js";
 import { getHealthStatus, getRecentErrors } from "../../util/watchdog.js";
-import { formatDuration, formatModelLabel } from "./helpers.js";
+import { formatDuration, formatModelLabel } from "./helpers/index.js";
 
 export async function handleAdminCommand(
   ctx: Context,
@@ -91,6 +93,7 @@ export async function handleAdminCommand(
         try {
           await bot.api.sendMessage(id, text);
           sent++;
+          await new Promise((r) => setTimeout(r, 40));
         } catch {
           failed++;
         }
@@ -116,20 +119,7 @@ export async function handleAdminCommand(
     case "logs": {
       const logPath = files.log;
       try {
-        const { statSync, openSync, readSync, closeSync } =
-          await import("node:fs");
-        const stat = statSync(logPath);
-        const size = Math.min(8192, stat.size);
-        const buf = Buffer.alloc(size);
-        const fd = openSync(logPath, "r");
-        readSync(fd, buf, 0, size, Math.max(0, stat.size - size));
-        closeSync(fd);
-        const lines = buf
-          .toString("utf-8")
-          .trim()
-          .split("\n")
-          .slice(-20)
-          .join("\n");
+        const lines = tailFile(logPath);
         await ctx.reply(`<pre>${escapeHtml(lines.slice(0, 3800))}</pre>`, {
           parse_mode: "HTML",
         });
@@ -187,14 +177,14 @@ export async function handleAdminCommand(
         return;
       }
       const lines = jobs.map((j) => {
-        const v = validateCronExpression(j.schedule, j.timezone);
+        const nextMs = nextRunAt(j);
         const last = j.lastRunAt
           ? new Date(j.lastRunAt).toISOString().slice(0, 16).replace("T", " ")
           : "never";
-        const next = v.next
-          ? new Date(v.next).toISOString().slice(0, 16).replace("T", " ")
+        const next = nextMs
+          ? new Date(nextMs).toISOString().slice(0, 16).replace("T", " ")
           : "?";
-        return `${j.enabled ? "\u2713" : "\u2717"} <b>${escapeHtml(j.name)}</b>\n  <code>${j.schedule}</code> | ${j.type} | runs: ${j.runCount} | last: ${last} | next: ${next}`;
+        return `${j.enabled ? "\u2713" : "\u2717"} <b>${escapeHtml(j.name)}</b>\n  <code>${escapeHtml(describeSchedule(j))}</code> | ${j.type} | runs: ${j.runCount} | last: ${last} | next: ${next}`;
       });
       await ctx.reply(
         `<b>Cron Jobs (${jobs.length})</b>\n\n` + lines.join("\n\n"),