@s0nderlabs/anima-plugin-telegram 0.19.1

package/src/listener.ts

@@ -0,0 +1,405 @@
+import { Bot, type Context, GrammyError, HttpError } from 'grammy'
+import { type ApprovalChoice, parseCallbackData } from './approval-keyboard'
+import { escapeChunkSuffixForMarkdownV2, splitMessage } from './chunking'
+import { DebounceBuffer, type FlushedBatch } from './debounce'
+import { formatTelegramChannel } from './format'
+import { RateLimiter } from './limits'
+import { escapeMarkdownV2, isMarkdownParseError, stripMarkdownV2 } from './markdown'
+import { formatPairingMessage } from './pairing-flow'
+import { reactError, reactProcessing, reactSuccess } from './reactions'
+import {
+  BotTokenLockedError,
+  type TokenLock,
+  acquireTelegramTokenLock,
+  classifyStartFailure,
+  clearWebhookBeforePolling,
+} from './recovery'
+import { DELIVERY_FAILURE_NOTICE, sendWithRetry } from './retry'
+import { sanitizeInbound } from './sanitize'
+import { buildSessionKey } from './session-key'
+import type { TelegramDispatchInput, TelegramRuntimeContext } from './types'
+
+/**
+ * Long-poll Telegram bot. Inbound DMs from allowedUserIds are debounced and
+ * dispatched to the brain via `dispatchUserMessage`. Reactions transition
+ * from 👀 (processing) → 👍/👎 (success/error). Reply text is sent back via
+ * grammy's `bot.api.sendMessage` with retry-classified backoff.
+ *
+ * Lifecycle: `start()` acquires a host-wide token lock, clears any stale
+ * webhook, then boots grammy in long-poll mode. `stop()` releases the lock
+ * and stops the bot. Both are idempotent.
+ */
+export interface TelegramListenerOpts extends TelegramRuntimeContext {
+  /** Optional override of the Telegram Bot API root. Used by the mock-bot test. */
+  apiRoot?: string
+  /** Optional per-user rate-limit. Default capacity=30, window=60s. */
+  rateLimit?: { capacity: number; windowMs: number }
+  /** Optional debounce window. Default 600ms. */
+  debounceMs?: number
+  /** Optional override of the locks dir (test only). */
+  lockRootDir?: string
+}
+
+export class TelegramListener {
+  private readonly opts: TelegramListenerOpts
+  private readonly bot: Bot
+  private readonly limiter: RateLimiter
+  private readonly debounce: DebounceBuffer
+  private readonly inflight = new Map<number, Promise<void>>()
+  private running = false
+  private tokenLock: TokenLock | null = null
+  private refreshTimer: ReturnType<typeof setInterval> | null = null
+
+  constructor(opts: TelegramListenerOpts) {
+    this.opts = opts
+    this.bot = new Bot(opts.botToken, opts.apiRoot ? { client: { apiRoot: opts.apiRoot } } : {})
+    this.limiter = new RateLimiter(opts.rateLimit)
+    this.debounce = new DebounceBuffer((chatId, batch) => this.handleFlushed(chatId, batch), {
+      quietPeriodMs: opts.debounceMs,
+    })
+    this.bot.on('message', ctx => this.onMessage(ctx))
+    this.bot.catch(err => {
+      const msg = err instanceof Error ? err.message : String(err)
+      this.log(`grammy.catch: ${msg.slice(0, 200)}`)
+    })
+  }
+
+  async start(): Promise<void> {
+    if (this.running) return
+
+    try {
+      this.tokenLock = acquireTelegramTokenLock(this.opts.botToken, {
+        agentId: this.opts.agentName,
+        rootDir: this.opts.lockRootDir,
+      })
+    } catch (err) {
+      if (err instanceof BotTokenLockedError) {
+        console.warn(`[telegram] cannot start listener: ${err.message}`)
+      }
+      throw err
+    }
+
+    this.running = true
+    console.log(`[telegram] listener.start() called for @${this.opts.agentName}`)
+
+    if (this.opts.allowedUserIds.length === 0 && !this.opts.pairingStore) {
+      console.warn(
+        '[telegram] no allowlist configured AND no pairing store. ' +
+          'All inbound messages will be DROPPED. Configure allowedUserIds via ' +
+          '`anima telegram setup` or enable pairing.',
+      )
+    }
+
+    // Wire approval bridge if the dispatcher provided one. The bridge has two
+    // slots: sendApproval (we fill with a closure over this.bot) and
+    // installCallbackHandler (we fill with a registrar over bot.on('callback_query')).
+    if (this.opts.approvalBridge) {
+      this.opts.approvalBridge.sendApproval.current = (chatId, text, approvalId) =>
+        this.sendApprovalMessage(chatId, text, approvalId)
+      this.opts.approvalBridge.installCallbackHandler.current = handler =>
+        this.installCallbackHandler(handler)
+    }
+
+    await clearWebhookBeforePolling(this.bot)
+
+    this.refreshTimer = setInterval(() => {
+      if (this.tokenLock && !this.tokenLock.refresh()) {
+        console.warn('[telegram] token lock lost - stopping listener')
+        void this.stop()
+      }
+    }, 60_000)
+
+    void this.bot
+      .start({
+        onStart: info => console.log(`[telegram] listener active @${info.username}`),
+        drop_pending_updates: true,
+        allowed_updates: ['message'],
+      })
+      .catch(err => {
+        const verdict = classifyStartFailure(err)
+        console.error(`[telegram] bot.start ${verdict.kind}: ${verdict.detail.slice(0, 400)}`)
+        this.running = false
+        this.releaseLock()
+      })
+  }
+
+  async stop(): Promise<void> {
+    if (!this.running) {
+      this.releaseLock()
+      return
+    }
+    this.running = false
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer)
+      this.refreshTimer = null
+    }
+    this.debounce.flushAll()
+    try {
+      await this.bot.stop()
+    } catch {
+      // grammy stop can throw if start hasn't completed; ignore.
+    }
+    await Promise.allSettled([...this.inflight.values()])
+    this.releaseLock()
+  }
+
+  private releaseLock(): void {
+    if (this.tokenLock) {
+      try {
+        this.tokenLock.release()
+      } catch {
+        /* best-effort */
+      }
+      this.tokenLock = null
+    }
+  }
+
+  /** Send the inline-keyboard approval message. Used by the approval bridge. */
+  private async sendApprovalMessage(
+    chatId: number,
+    body: string,
+    approvalId: string,
+  ): Promise<void> {
+    const { buildApprovalKeyboard } = await import('./approval-keyboard')
+    await sendWithRetry(() =>
+      this.bot.api.sendMessage(chatId, body, {
+        reply_markup: buildApprovalKeyboard(approvalId),
+      }),
+    )
+  }
+
+  /**
+   * Register a single callback_query dispatcher. Parses + re-validates the
+   * clicker against `allowedUserIds`, then forwards to the caller's resolver
+   * which owns the pending-approval Map. grammy doesn't expose middleware
+   * unregister, so we no-op the returned function and rely on bot.stop()
+   * for teardown.
+   */
+  private installCallbackHandler(
+    onResolve: (approvalId: string, choice: ApprovalChoice, fromUserId: number) => void,
+  ): () => void {
+    const handler = async (ctx: Context): Promise<void> => {
+      const q = ctx.callbackQuery
+      if (!q) return
+      const parsed = parseCallbackData(q.data)
+      if (!parsed) {
+        try {
+          await ctx.answerCallbackQuery({ text: 'malformed approval callback' })
+        } catch {
+          /* ignore */
+        }
+        return
+      }
+      if (this.opts.allowedUserIds.length > 0 && !this.opts.allowedUserIds.includes(q.from.id)) {
+        try {
+          await ctx.answerCallbackQuery({ text: '⛔ You are not authorized to approve commands.' })
+        } catch {
+          /* ignore */
+        }
+        return
+      }
+      onResolve(parsed.approvalId, parsed.choice, q.from.id)
+      try {
+        await ctx.answerCallbackQuery({ text: `✓ ${parsed.choice}` })
+      } catch {
+        /* ignore */
+      }
+    }
+    this.bot.on('callback_query:data', handler)
+    return () => {}
+  }
+
+  /**
+   * Handle one inbound TG update. Sanitize → rate-limit → debounce.
+   * Errors here are swallowed (logged) so grammy stays alive.
+   */
+  private async onMessage(ctx: Context): Promise<void> {
+    const msg = ctx.message
+    if (!msg) return
+    const sanitized = sanitizeInbound(
+      {
+        chatType: msg.chat.type,
+        chatId: msg.chat.id,
+        fromId: msg.from?.id ?? null,
+        fromIsBot: msg.from?.is_bot ?? false,
+        fromUsername: msg.from?.username ?? null,
+        fromFirstName: msg.from?.first_name ?? null,
+        fromLastName: msg.from?.last_name ?? null,
+        text: msg.text ?? msg.caption ?? null,
+        messageId: msg.message_id,
+        forwardedFrom:
+          (msg as { forward_from?: unknown; forward_origin?: unknown }).forward_from ??
+          (msg as { forward_origin?: unknown }).forward_origin ??
+          null,
+        mediaGroupId: msg.media_group_id ?? null,
+      },
+      {
+        allowedUserIds: this.opts.allowedUserIds,
+        pairingStore: this.opts.pairingStore,
+      },
+    )
+    if (!sanitized.ok) {
+      if (sanitized.action === 'send-pairing-code' && sanitized.code) {
+        const text = formatPairingMessage({
+          code: sanitized.code,
+          agentName: this.opts.agentName,
+        })
+        try {
+          await this.bot.api.sendMessage(msg.chat.id, text)
+        } catch (sendErr) {
+          this.log(`pairing-code send failed: ${(sendErr as Error).message?.slice(0, 200) ?? ''}`)
+        }
+      }
+      this.log(`drop: ${sanitized.reason} from chat=${msg.chat.id}`)
+      return
+    }
+    const event = sanitized.event
+    if (this.limiter.shouldDrop(event.userId)) {
+      this.log(`rate-limit-drop user=${event.userId}`)
+      void reactError(this.bot, event.chatId, event.messageId)
+      return
+    }
+    this.debounce.push(event.chatId, {
+      text: event.text,
+      messageId: event.messageId,
+      ts: event.ts,
+      userId: event.userId,
+      username: event.username,
+      displayName: event.displayName,
+    })
+  }
+
+  private handleFlushed(chatId: number, batch: FlushedBatch): void {
+    const existing = this.inflight.get(chatId)
+    const next = (existing ?? Promise.resolve()).then(() => this.dispatchOne(chatId, batch))
+    this.inflight.set(
+      chatId,
+      next.finally(() => {
+        if (this.inflight.get(chatId) === next) this.inflight.delete(chatId)
+      }),
+    )
+  }
+
+  private async dispatchOne(chatId: number, batch: FlushedBatch): Promise<void> {
+    const messageId = batch.latestMessageId
+    void reactProcessing(this.bot, chatId, messageId)
+    if (this.opts.onProcessingStart) {
+      try {
+        await this.opts.onProcessingStart(chatId, messageId)
+      } catch {
+        /* never block on hook failures */
+      }
+    }
+    let ok = true
+    try {
+      const input: TelegramDispatchInput = {
+        text: batch.text,
+        chatId,
+        userId: batch.userId,
+        username: batch.username,
+        displayName: batch.displayName,
+        latestMessageId: messageId,
+        sessionKey: buildSessionKey({ agentName: this.opts.agentName, chatId }),
+      }
+      const channelText = formatTelegramChannel({
+        chatId,
+        username: batch.username,
+        displayName: batch.displayName,
+        text: batch.text,
+      })
+      const result = await this.opts.dispatchUserMessage({ ...input, text: channelText })
+      const reply = result.response.trim()
+      if (reply.length > 0) {
+        await this.sendChunked(chatId, reply, messageId)
+      }
+      void reactSuccess(this.bot, chatId, messageId)
+    } catch (err) {
+      ok = false
+      const msg = err instanceof Error ? err.message : String(err)
+      this.log(`dispatch failed: ${msg.slice(0, 200)}`)
+      void reactError(this.bot, chatId, messageId)
+      try {
+        await this.bot.api.sendMessage(
+          chatId,
+          'sorry, something went wrong on my side. try again in a moment.',
+          { reply_parameters: { message_id: messageId, allow_sending_without_reply: true } },
+        )
+      } catch {
+        /* swallow */
+      }
+    }
+    if (this.opts.onProcessingEnd) {
+      try {
+        await this.opts.onProcessingEnd(chatId, messageId, ok)
+      } catch {
+        /* never block */
+      }
+    }
+  }
+
+  /**
+   * Send a (possibly long) reply with MarkdownV2 + chunking. Falls back to
+   * plain-text on parse_error. On retry exhaustion, sends the delivery-failure
+   * notice. First chunk is reply-linked; subsequent chunks are not.
+   */
+  private async sendChunked(chatId: number, body: string, replyToMessageId: number): Promise<void> {
+    const chunks = splitMessage(body)
+    let firstSend = true
+    for (const chunk of chunks) {
+      const md = escapeChunkSuffixForMarkdownV2(escapeMarkdownV2(chunk))
+      try {
+        await sendWithRetry(() =>
+          this.bot.api.sendMessage(chatId, md, {
+            parse_mode: 'MarkdownV2',
+            reply_parameters: firstSend
+              ? { message_id: replyToMessageId, allow_sending_without_reply: true }
+              : undefined,
+          }),
+        )
+      } catch (err) {
+        if (isMarkdownParseError(err)) {
+          // Plain-text fallback for this chunk
+          try {
+            await sendWithRetry(() =>
+              this.bot.api.sendMessage(chatId, stripMarkdownV2(chunk), {
+                reply_parameters: firstSend
+                  ? { message_id: replyToMessageId, allow_sending_without_reply: true }
+                  : undefined,
+              }),
+            )
+          } catch (fallbackErr) {
+            // Even plain-text failed; surface delivery-failure notice once.
+            this.log(`send fallback failed: ${(fallbackErr as Error).message?.slice(0, 200)}`)
+            try {
+              await this.bot.api.sendMessage(chatId, DELIVERY_FAILURE_NOTICE)
+            } catch {
+              /* best-effort */
+            }
+            return
+          }
+        } else {
+          this.log(`send failed: ${(err as Error).message?.slice(0, 200)}`)
+          try {
+            await this.bot.api.sendMessage(chatId, DELIVERY_FAILURE_NOTICE)
+          } catch {
+            /* best-effort */
+          }
+          return
+        }
+      }
+      firstSend = false
+    }
+  }
+
+  private log(line: string): void {
+    if (this.opts.debug) console.log(`[telegram] ${line}`)
+  }
+}
+
+/** Telegram caps messages at 4096 chars. We cap at 4000 to leave header room. */
+export function capForTelegram(text: string): string {
+  if (text.length <= 4000) return text
+  return `${text.slice(0, 3970)}\n[reply truncated]`
+}
+
+export { GrammyError, HttpError }

package/src/markdown.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'bun:test'
+import { escapeMarkdownV2, isMarkdownParseError, stripMarkdownV2 } from './markdown'
+
+describe('escapeMarkdownV2', () => {
+  it('escapes all reserved characters', () => {
+    expect(escapeMarkdownV2('a_b*c')).toBe('a\\_b\\*c')
+    expect(escapeMarkdownV2('hello [world]')).toBe('hello \\[world\\]')
+    expect(escapeMarkdownV2('1.2.3')).toBe('1\\.2\\.3')
+    expect(escapeMarkdownV2('a-b+c')).toBe('a\\-b\\+c')
+    expect(escapeMarkdownV2('!hi')).toBe('\\!hi')
+  })
+
+  it('passes plain text untouched', () => {
+    expect(escapeMarkdownV2('hello world')).toBe('hello world')
+    expect(escapeMarkdownV2('abc 123')).toBe('abc 123')
+  })
+
+  it('escapes backslashes themselves', () => {
+    expect(escapeMarkdownV2('path\\to')).toBe('path\\\\to')
+  })
+})
+
+describe('stripMarkdownV2', () => {
+  it('removes escape backslashes', () => {
+    expect(stripMarkdownV2('a\\.b\\.c')).toBe('a.b.c')
+    expect(stripMarkdownV2('hello\\!')).toBe('hello!')
+  })
+
+  it('strips bold markers', () => {
+    expect(stripMarkdownV2('*hello*')).toBe('hello')
+    expect(stripMarkdownV2('this is *bold*.')).toBe('this is bold.')
+  })
+
+  it('strips spoiler markers', () => {
+    expect(stripMarkdownV2('this is ||hidden||.')).toBe('this is hidden.')
+  })
+
+  it('strips strikethrough markers', () => {
+    expect(stripMarkdownV2('~deleted~ now')).toBe('deleted now')
+  })
+
+  it('preserves plain text', () => {
+    expect(stripMarkdownV2('hello world')).toBe('hello world')
+  })
+
+  it('strips a chain of formatting on one line', () => {
+    expect(stripMarkdownV2('*bold* and ~strike~ together')).toBe('bold and strike together')
+  })
+})
+
+describe('isMarkdownParseError', () => {
+  it('matches the canonical TG parse error string', () => {
+    expect(isMarkdownParseError(new Error("Bad Request: can't parse entities: ..."))).toBe(true)
+  })
+
+  it('matches hermes-cited variant', () => {
+    expect(isMarkdownParseError(new Error('cannot parse entities at offset 5'))).toBe(true)
+  })
+
+  it('is false for unrelated errors', () => {
+    expect(isMarkdownParseError(new Error('Forbidden'))).toBe(false)
+    expect(isMarkdownParseError(new Error('ECONNRESET'))).toBe(false)
+  })
+})

package/src/markdown.ts

@@ -0,0 +1,50 @@
+// MarkdownV2 escape + plain-text fallback.
+//
+// Pattern from hermes telegram.py:84. The Bot API requires every reserved
+// character in MarkdownV2 entity ranges to be escaped with backslash, even
+// inside code blocks for some characters. This module exposes a single
+// `escapeMarkdownV2` function for the safe path and `stripMarkdownV2` for
+// the plain-text fallback when parse_error fires on send.
+
+const MARKDOWN_V2_ESCAPE_REGEX = /([_*[\]()~`>#+\-=|{}.!\\])/g
+
+export function escapeMarkdownV2(text: string): string {
+  return text.replace(MARKDOWN_V2_ESCAPE_REGEX, '\\$1')
+}
+
+/**
+ * Strip MarkdownV2 markers so a parse_error fallback can send the same content
+ * as plain text. Handles the four common formatting markers (`*bold*`,
+ * `_italic_`, `~strike~`, `||spoiler||`) plus drops escape backslashes.
+ *
+ * Code-block markers stay (TG renders them as plain text without parse_mode).
+ */
+export function stripMarkdownV2(text: string): string {
+  let out = text
+  // Drop escape backslashes that were applied by escapeMarkdownV2
+  out = out.replace(/\\([_*[\]()~`>#+\-=|{}.!\\])/g, '$1')
+  // Strip ||spoiler|| (must run before * and _ since `||` shares chars)
+  out = out.replace(/\|\|([^|]+)\|\|/g, '$1')
+  // Strip *bold* (greedy-safe since markdown only allows single-line *bold*)
+  out = out.replace(/\*([^*]+)\*/g, '$1')
+  // Strip _italic_
+  out = out.replace(/(?:^|[\s])_([^_]+)_(?=[\s]|$)/g, ' $1')
+  // Strip ~strike~
+  out = out.replace(/~([^~]+)~/g, '$1')
+  return out
+}
+
+/**
+ * Detect if a grammy / Bot API error is a MarkdownV2 parse error so callers
+ * can fall back to plain-text. Hermes pattern: the error message contains
+ * "can't parse entities" with the MarkdownV2 mention.
+ */
+export function isMarkdownParseError(err: unknown): boolean {
+  const msg = err instanceof Error ? err.message : String(err)
+  const lower = msg.toLowerCase()
+  return (
+    lower.includes("can't parse entities") ||
+    lower.includes('cannot parse entities') ||
+    (lower.includes('bad request') && (lower.includes('parse') || lower.includes('entities')))
+  )
+}

package/src/pairing-flow.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'bun:test'
+import { formatPairingMessage } from './pairing-flow'
+
+describe('formatPairingMessage', () => {
+  it('includes the code and the default approve command', () => {
+    const msg = formatPairingMessage({ code: 'ABCDEFGH' })
+    expect(msg).toContain('ABCDEFGH')
+    expect(msg).toContain('anima pairing approve telegram ABCDEFGH')
+  })
+
+  it('greets with the agent name when provided', () => {
+    const msg = formatPairingMessage({ code: 'ABCDEFGH', agentName: 'specter' })
+    expect(msg).toContain('specter')
+  })
+
+  it('mentions 1-hour TTL', () => {
+    const msg = formatPairingMessage({ code: 'ABCDEFGH' })
+    expect(msg).toContain('1 hour')
+  })
+
+  it('honors approveCommand override', () => {
+    const msg = formatPairingMessage({ code: 'XX', approveCommand: 'custom-cmd XX' })
+    expect(msg).toContain('custom-cmd XX')
+    expect(msg).not.toContain('anima pairing approve')
+  })
+
+  it('starts with the lock emoji', () => {
+    const msg = formatPairingMessage({ code: 'XX' })
+    expect(msg.startsWith('🔐')).toBe(true)
+  })
+})

package/src/pairing-flow.ts

@@ -0,0 +1,31 @@
+// Pairing-flow message formatter.
+//
+// When an unknown user DMs the bot, the listener replies with a pairing code
+// they can give to the operator. The operator approves out-of-band via
+// `anima pairing approve telegram <code>`, which writes the user-id to
+// `~/.anima/agents/<id>/pairing/telegram-approved.json`. The next message
+// from that user passes sanitize and reaches the brain.
+
+export interface PairingMessageOpts {
+  code: string
+  agentName?: string
+  /** Optional override of the approval CLI hint. */
+  approveCommand?: string
+}
+
+export function formatPairingMessage(opts: PairingMessageOpts): string {
+  const cmd = opts.approveCommand ?? `anima pairing approve telegram ${opts.code}`
+  const greeting = opts.agentName
+    ? `🔐 Hi! I'm ${opts.agentName} and I don't recognize you yet.`
+    : "🔐 Hi! I don't recognize you yet."
+  return [
+    greeting,
+    '',
+    `Your pairing code: ${opts.code}`,
+    '',
+    'Send this code to the bot owner and ask them to approve you. They will run:',
+    `  ${cmd}`,
+    '',
+    "Codes expire in 1 hour. Once approved, send your next message and I'll respond.",
+  ].join('\n')
+}

package/src/reactions.ts

@@ -0,0 +1,54 @@
+/**
+ * Atomic reaction state machine: 👀 (processing) → 👍 (success) | 👎 (error).
+ * Telegram's setMessageReaction REPLACES all bot reactions on the message in
+ * one call, so transitions are atomic. No remove step needed.
+ *
+ * If the bot doesn't have permission to react in the chat (rare for DMs but
+ * possible if the user blocks), the call fails silently and message handling
+ * continues. We never let a reaction failure abort a brain turn.
+ */
+import type { Bot } from 'grammy'
+import type { ReactionTypeEmoji } from 'grammy/types'
+
+type Emoji = ReactionTypeEmoji['emoji']
+
+export const REACTION_PROCESSING: Emoji = '\u{1F440}' // 👀
+export const REACTION_OK: Emoji = '\u{1F44D}' // 👍
+export const REACTION_ERR: Emoji = '\u{1F44E}' // 👎
+
+export async function reactProcessing(bot: Bot, chatId: number, messageId: number): Promise<void> {
+  await safeSetReaction(bot, chatId, messageId, REACTION_PROCESSING)
+}
+
+export async function reactSuccess(bot: Bot, chatId: number, messageId: number): Promise<void> {
+  await safeSetReaction(bot, chatId, messageId, REACTION_OK)
+}
+
+export async function reactError(bot: Bot, chatId: number, messageId: number): Promise<void> {
+  await safeSetReaction(bot, chatId, messageId, REACTION_ERR)
+}
+
+export async function clearReaction(bot: Bot, chatId: number, messageId: number): Promise<void> {
+  await safeSetReactionEmpty(bot, chatId, messageId)
+}
+
+async function safeSetReaction(
+  bot: Bot,
+  chatId: number,
+  messageId: number,
+  emoji: Emoji,
+): Promise<void> {
+  try {
+    await bot.api.setMessageReaction(chatId, messageId, [{ type: 'emoji', emoji }])
+  } catch {
+    // Reaction failures are cosmetic; never block the turn on them.
+  }
+}
+
+async function safeSetReactionEmpty(bot: Bot, chatId: number, messageId: number): Promise<void> {
+  try {
+    await bot.api.setMessageReaction(chatId, messageId, [])
+  } catch {
+    // Same: silent.
+  }
+}