@rhizogrip/spore-plugin-telegram 0.4.0 → 0.5.0

package/README.md

@@ -49,7 +49,9 @@ Write to the bot and the message goes to the spore the chat is mapped to, which
 wrote it and where — your name and username, the private chat or the group. The bot posts
 `working…` and shows which tools run as they run. When the turn ends, the answer arrives as a new
 message replying to yours, so it notifies you however long the turn took, and `working…` is
-removed; one Telegram will no longer let the bot remove, past 48 hours, says `answered below`. How
+removed; one Telegram will no longer let the bot remove, past 48 hours, says `answered below`. The
+answer's Markdown is shown as Telegram formats it — bold, italic, code, code blocks, links, quotes;
+a heading as a bold line, a table in a monospace block — and as plain text if Telegram refuses it. How
 the turn ended is added only when it makes the answer partial — a wrap or a stop. A longer answer
 than Telegram's 4096 continues in further messages. What the turn left in `data/out/` follows as
 documents, up to the 50 a turn hands back, then a line counting the rest; a file over Telegram's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhizogrip/spore-plugin-telegram",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Telegram for spores: a bot of yours in chats, each chat reaching its spore, run as a service",
   "author": {
     "name": "Christophe Le Bars",
@@ -27,14 +27,17 @@
     "README.md",
     "NOTICE"
   ],
+  "dependencies": {
+    "marked": "^18.0.11"
+  },
   "peerDependencies": {
-    "@rhizogrip/spore": "^1.15.0"
+    "@rhizogrip/spore": "^1.16.0"
   },
   "scripts": {
     "test": "vitest run"
   },
   "spore": {
-    "works": "^1.15.0",
+    "works": "^1.16.0",
     "services": {
       "telegram": {
         "what": "a bot of yours in Telegram chats, each chat reaching its spore",

package/src/adapter.js

@@ -6,8 +6,11 @@
 
 import { SporeError } from '@rhizogrip/spore'
 
+import { toHtml } from './format.js'
+
 const COMMAND = /^\/([a-z]+)(@\w+)?(?:\s+(.+))?$/is
 const NOT_MODIFIED = /message is not modified/
+const CANNOT_PARSE = /can't parse entities/i
 const SHAPE = '{ "token": "${TRIAGE_BOT_TOKEN}", "chats": { "<chat id>": "<spore>" } }' // eslint-disable-line no-template-curly-in-string
 
 const said = (err) => [err.message, err.detail].filter(Boolean).join(' — ')
@@ -124,7 +127,14 @@ export function createAdapter ({ telegram, bot }) {
       }
     },
 
-    post: async (conversation, text, { answering = null } = {}) => (await telegram.say(Number(conversation), text, { answering })).message_id,
+    post: async (conversation, text, { answering = null, markdown = false } = {}) => {
+      try {
+        return (await telegram.say(Number(conversation), markdown ? toHtml(text) : text, { answering, html: markdown })).message_id
+      } catch (err) {
+        if (!markdown || !CANNOT_PARSE.test(err.detail ?? '')) throw err
+        throw new SporeError('Telegram refused the formatting', { type: 'TELEGRAM_FORMAT_REFUSED', detail: err.detail, context: { formatRefused: true } })
+      }
+    },
 
     edit: async (conversation, note, text) => {
       try {

package/src/api.js

@@ -51,10 +51,11 @@ export function createTelegram (token, { fetchImpl = fetch, base = BASE } = {})
     updates: (offset, { seconds = 30, signal } = {}) =>
       call('getUpdates', { offset, timeout: seconds, allowed_updates: ['message'] }, { timeoutMs: (seconds + 15) * 1000, signal }),
 
-    say: (chat, text, { answering = null } = {}) => call('sendMessage', {
+    say: (chat, text, { answering = null, html = false } = {}) => call('sendMessage', {
       chat_id: chat,
       text,
       link_preview_options: { is_disabled: true },
+      ...(html ? { parse_mode: 'HTML' } : {}),
       ...(answering === null ? {} : { reply_parameters: { message_id: answering, allow_sending_without_reply: true } })
     }),
 

package/src/format.js

@@ -0,0 +1,76 @@
+/**
+ * Markdown, as a model writes it, in the HTML Telegram renders. Bold, italic, strikethrough, code,
+ * code blocks with their language, links and quotes are Telegram's own; a heading becomes a bold
+ * line, a list keeps its bullets as text, a table becomes a monospace block. Telegram refuses a
+ * message holding any tag outside its small set, so everything else is escaped and shown as written.
+ */
+
+import { Lexer } from 'marked'
+
+const LINKABLE = /^(https?:|mailto:|tg:)/i
+
+const escape = (text) => String(text).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+const attribute = (text) => escape(text).replace(/"/g, '&quot;')
+
+const plain = (tokens) => tokens.map(token => (token.tokens ? plain(token.tokens) : token.text ?? '')).join('')
+
+function inline (tokens) {
+  return tokens.map((token) => {
+    if (token.type === 'strong') return `<b>${inline(token.tokens)}</b>`
+    if (token.type === 'em') return `<i>${inline(token.tokens)}</i>`
+    if (token.type === 'del') return `<s>${inline(token.tokens)}</s>`
+    if (token.type === 'codespan') return `<code>${escape(token.text)}</code>`
+    if (token.type === 'br') return '\n'
+    if (token.type === 'link') return LINKABLE.test(token.href) ? `<a href="${attribute(token.href)}">${inline(token.tokens)}</a>` : inline(token.tokens)
+    if (token.type === 'image') return LINKABLE.test(token.href) ? `<a href="${attribute(token.href)}">${escape(token.text || token.href)}</a>` : escape(token.text)
+    if (token.type === 'text') return token.tokens ? inline(token.tokens) : escape(token.text)
+    if (token.type === 'escape') return escape(token.text)
+    if (token.type === 'checkbox') return token.checked ? '☑ ' : '☐ '
+    return escape(token.raw)
+  }).join('')
+}
+
+function list (token, depth) {
+  const indent = '  '.repeat(depth)
+  return token.items.map((item, i) => {
+    const mark = token.ordered ? `${Number(token.start) + i}.` : '•'
+    const box = item.tokens.filter(child => child.type === 'checkbox').map(child => inline([child])).join('')
+    const parts = item.tokens.filter(child => child.type !== 'checkbox').map(child => (child.type === 'list' ? list(child, depth + 1) : block([child], depth + 1)))
+    return `${indent}${mark} ${box}${parts.join('\n')}`
+  }).join('\n')
+}
+
+function table (token) {
+  const rows = [token.header, ...token.rows].map(row => row.map(cell => plain(cell.tokens)))
+  const widths = rows[0].map((_, column) => Math.max(...rows.map(row => row[column].length)))
+  const line = (row) => row.map((cell, column) => cell.padEnd(widths[column])).join(' | ').trimEnd()
+  return `<pre>${escape([line(rows[0]), widths.map(width => '-'.repeat(width)).join('-+-'), ...rows.slice(1).map(line)].join('\n'))}</pre>`
+}
+
+function block (tokens, depth = 0) {
+  const out = []
+  for (const token of tokens) {
+    if (token.type === 'space') continue
+    if (token.type === 'code') {
+      const language = token.lang?.split(/\s/)[0]
+      out.push(`<pre><code${language ? ` class="language-${attribute(language)}"` : ''}>${escape(token.text)}</code></pre>`)
+    } else if (token.type === 'heading') {
+      out.push(`<b>${inline(token.tokens)}</b>`)
+    } else if (token.type === 'paragraph' || token.type === 'text') {
+      out.push(inline(token.tokens ?? [token]))
+    } else if (token.type === 'blockquote') {
+      out.push(`<blockquote>${block(token.tokens, depth)}</blockquote>`)
+    } else if (token.type === 'list') {
+      out.push(list(token, depth))
+    } else if (token.type === 'table') {
+      out.push(table(token))
+    } else if (token.type === 'hr') {
+      out.push('──────────')
+    } else {
+      out.push(escape(token.raw.trimEnd()))
+    }
+  }
+  return out.join('\n\n')
+}
+
+export const toHtml = (markdown) => block(Lexer.lex(String(markdown)))