@goodandready/dsh-messenger-gateway 0.2.0 → 0.3.0

package/lib/adapters/index.js

@@ -15,6 +15,9 @@ export default function createAdapters(deps) {
       groupsEnabled: tg.groupsEnabled,
       groupRequireMention: tg.groupRequireMention,
       reactionsEnabled: tg.reactionsEnabled,
+      statusIndicator: tg.statusIndicator,
+      statusOnline: tg.statusOnline,
+      statusOffline: tg.statusOffline,
       transport: tg.transport,
       webhookUrl: tg.webhookUrl,
       webhookSecret: tg.webhookSecret,

package/lib/adapters/telegram.js

@@ -11,6 +11,7 @@ import { normalizeThreadId, telegramThreadParams } from '../topics.js'
 import {
   shouldProcessTelegramMessage, stripBotCommandSuffix,
 } from '../groups.js'
+import { isResendSafeNetworkError, isPollingConflict } from '../telegram-errors.js'
 
 const API = 'https://api.telegram.org'
 const TELEGRAM_MAX = 4096
@@ -34,6 +35,12 @@ export class TelegramAdapter {
     this.groupRequireMention = opts.groupRequireMention !== false
     this.reactionsEnabled = opts.reactionsEnabled !== false
     this.transport = opts.transport === 'webhook' ? 'webhook' : 'poll'
+    this.statusIndicator = opts.statusIndicator === true
+    this.statusOnline = String(opts.statusOnline || 'Online')
+    this.statusOffline = String(opts.statusOffline || 'Offline')
+    this.sendRetryMax = 2
+    this.sendRetryBaseMs = 400
+    this.pollingConflict = false
     this.webhookUrl = String(opts.webhookUrl || '').trim()
     this.webhookSecret = String(opts.webhookSecret || '').trim()
     this.offset = 0
@@ -63,6 +70,24 @@ export class TelegramAdapter {
     return json.result
   }
 
+  // Retry a send only on resend-safe network errors (request never reached Telegram).
+  // Permanent errors (4xx/5xx) and ambiguous timeouts are not retried to avoid duplicates.
+  async sendWithRetry(method, params, { multipart = false } = {}) {
+    const fn = () => (multipart ? this.callMultipart(method, params) : this.call(method, params))
+    let lastErr
+    for (let attempt = 0; attempt <= this.sendRetryMax; attempt++) {
+      try {
+        return await fn()
+      } catch (err) {
+        lastErr = err
+        if (!isResendSafeNetworkError(err) || attempt >= this.sendRetryMax) throw err
+        this.logger?.warn?.(`telegram ${method} resend-safe network error (attempt ${attempt + 1}/${this.sendRetryMax}), retrying: ${err.message}`)
+        await new Promise((r) => setTimeout(r, this.sendRetryBaseMs * (attempt + 1)))
+      }
+    }
+    throw lastErr
+  }
+
   async getFile(fileId) { return this.call('getFile', { file_id: fileId }) }
 
   async downloadFile(filePath) {
@@ -76,6 +101,17 @@ export class TelegramAdapter {
     await this.call('setMyCommands', { commands: this.commands })
   }
 
+  // Bots have no presence dot; the short description is the closest surface.
+  // Opt-in only — it mutates the bot's global profile visible to all users.
+  async setStatusIndicator(text) {
+    if (!this.statusIndicator) return
+    try {
+      await this.call('setMyShortDescription', { short_description: String(text || '').slice(0, 120) })
+    } catch (err) {
+      this.logger?.warn?.(`telegram setMyShortDescription: ${err.message}`)
+    }
+  }
+
   async start() {
     if (!this.token) throw new Error('telegram bot token is empty')
     this.stopped = false
@@ -87,6 +123,7 @@ export class TelegramAdapter {
     } catch (err) {
       this.logger?.warn?.(`dsh-messenger-gateway: telegram getMe: ${err.message}`)
     }
+    if (this.statusIndicator) await this.setStatusIndicator(this.statusOnline)
     try {
       await this.registerCommands()
       this.logger?.info?.(`dsh-messenger-gateway: telegram commands registered (${this.commands.length})`)
@@ -115,6 +152,7 @@ export class TelegramAdapter {
   stop() {
     this.stopped = true
     if (this.pollTimer) clearTimeout(this.pollTimer)
+    if (this.statusIndicator) this.setStatusIndicator(this.statusOffline).catch(() => {})
   }
 
   schedulePoll() {
@@ -131,12 +169,20 @@ export class TelegramAdapter {
         offset: this.offset,
         allowed_updates: ['message', 'callback_query'],
       })
+      this.pollingConflict = false
       for (const update of updates || []) {
         this.offset = Math.max(this.offset, update.update_id + 1)
         await this.dispatchUpdate(update)
       }
     } catch (e) {
-      if (!this.stopped) this.logger?.warn?.(`poll: ${e.message}`)
+      if (!this.stopped) {
+        if (isPollingConflict(e)) {
+          this.pollingConflict = true
+          this.logger?.error?.(`poll: TELEGRAM CONFLICT — another bot instance is polling the same token. Stop the duplicate instance. (${e.message})`)
+        } else {
+          this.logger?.warn?.(`poll: ${e.message}`)
+        }
+      }
     }
     this.schedulePoll()
   }
@@ -422,12 +468,12 @@ export class TelegramAdapter {
     if (thread.message_thread_id) form.append('message_thread_id', String(thread.message_thread_id))
     const blob = new Blob([file.bytes])
     const name = safeName(file.name || 'file')
-    if (file.kind === 'photo') { form.append('photo', blob, name); return this.callMultipart('sendPhoto', form) }
-    if (file.kind === 'voice') { form.append('voice', blob, name); return this.callMultipart('sendVoice', form) }
-    if (file.kind === 'audio') { form.append('audio', blob, name); return this.callMultipart('sendAudio', form) }
-    if (file.kind === 'video') { form.append('video', blob, name); return this.callMultipart('sendVideo', form) }
+    if (file.kind === 'photo') { form.append('photo', blob, name); return this.sendWithRetry('sendPhoto', form, { multipart: true }) }
+    if (file.kind === 'voice') { form.append('voice', blob, name); return this.sendWithRetry('sendVoice', form, { multipart: true }) }
+    if (file.kind === 'audio') { form.append('audio', blob, name); return this.sendWithRetry('sendAudio', form, { multipart: true }) }
+    if (file.kind === 'video') { form.append('video', blob, name); return this.sendWithRetry('sendVideo', form, { multipart: true }) }
     form.append('document', blob, name)
-    return this.callMultipart('sendDocument', form)
+    return this.sendWithRetry('sendDocument', form, { multipart: true })
   }
 
   formatOutgoingText(text, payload = {}) {
@@ -451,7 +497,7 @@ export class TelegramAdapter {
       }
       if (parseMode) params.parse_mode = parseMode
       try {
-        await this.call('sendMessage', params)
+        await this.sendWithRetry('sendMessage', params)
       } catch (err) {
         if (!parseMode) throw err
         this.logger?.warn?.(`telegram HTML send failed, fallback plain: ${err.message}`)

package/lib/client.js

@@ -98,6 +98,8 @@ const css =
       groupMention: 'Groups require @mention / reply / command',
       reactionsEnable: 'React while processing (👀)',
       progressEnable: 'Progress message (thinking → delete → final)',
+      statusIndicator: 'Status indicator (Online/Offline)',
+      statusIndicatorHint: 'Sets the bot short description; bots have no presence dot. Opt-in, visible to all users.',
       transport: 'Transport',
       transportPoll: 'Long poll (getUpdates)',
       transportWebhook: 'Webhook',
@@ -167,6 +169,8 @@ const css =
       groupMention: 'В группах только @mention / reply / команда',
       reactionsEnable: 'Реакция 👀 пока думает',
       progressEnable: 'Прогресс: думаю → удалить → финальный ответ',
+      statusIndicator: 'Индикатор статуса (Online/Offline)',
+      statusIndicatorHint: 'Меняет short description бота (у ботов нет точки присутствия). Опцionalно, видно всем.',
       transport: 'Транспорт',
       transportPoll: 'Long poll (getUpdates)',
       transportWebhook: 'Webhook',
@@ -410,6 +414,11 @@ const css =
             React.createElement('input', { type: 'checkbox', checked: cfg.telegram?.progressEnabled !== false, onChange: (e) => setCfg({ ...cfg, telegram: { ...cfg.telegram, progressEnabled: e.target.checked } }) }),
             t('progressEnable'),
           ),
+          React.createElement('label', { className: 'msgw-check' },
+            React.createElement('input', { type: 'checkbox', checked: cfg.telegram?.statusIndicator === true, onChange: (e) => setCfg({ ...cfg, telegram: { ...cfg.telegram, statusIndicator: e.target.checked } }) }),
+            t('statusIndicator'),
+          ),
+          React.createElement('div', { className: 'msgw-hint' }, t('statusIndicatorHint')),
           React.createElement(Field, { label: t('voiceMode') },
             React.createElement('select', { className: 'msgw-select', value: cfg.telegram?.voiceMode || 'mirror', onChange: (e) => setCfg({ ...cfg, telegram: { ...cfg.telegram, voiceMode: e.target.value } }) },
               React.createElement('option', { value: 'mirror' }, t('voiceModeMirror')),

package/lib/config.js

@@ -31,6 +31,9 @@ export const PluginConfig = z.object({
     groupsEnabled: z.boolean().default(true).description('Process group/supergroup messages'),
     groupRequireMention: z.boolean().default(true).description('In groups, only respond to @mention, reply-to-bot, or /commands'),
     reactionsEnabled: z.boolean().default(true).description('React with 👀 while processing a turn'),
+    statusIndicator: z.boolean().default(false).description('Opt-in: set bot short description to Online/Offline (bots have no presence)'),
+    statusOnline: z.string().default('Online'),
+    statusOffline: z.string().default('Offline'),
     transport: z.union([z.const('poll'), z.const('webhook')]).default('poll'),
     webhookUrl: z.string().default(''),
     webhookSecret: z.string().role('secret').default(''),

package/lib/gateway.js

@@ -24,6 +24,7 @@ import {
   extractTextDelta, extractToolName, buildStreamPreview, formatProgressLine,
   createEditScheduler, startTypingHeartbeat,
 } from './stream.js'
+import { isTopicGoneError } from './telegram-errors.js'
 
 function whenIdleWithTimeout(agent, timeoutMs, signal) {
   const idle = agent.whenIdle()
@@ -170,7 +171,15 @@ export class Gateway {
     }
     const adapter = this.getAdapter(resolved.platform)
     if (!adapter?.sendTo) throw new Error(`adapter ${resolved.platform} unavailable`)
-    await adapter.sendTo(resolved.chatId, payload, { threadId: resolved.threadId })
+    try {
+      await adapter.sendTo(resolved.chatId, payload, { threadId: resolved.threadId })
+    } catch (err) {
+      if (isTopicGoneError(err)) {
+        this.logger?.warn?.(`messengerSend: topic gone for ${resolved.platform}:${resolved.chatId}:${resolved.threadId} — the chat/topic was deleted; skipping delivery`)
+        return
+      }
+      throw err
+    }
   }
 
   async messengerAsk(target, payload, timeoutMs = 300_000) {
@@ -179,7 +188,17 @@ export class Gateway {
     const token = makeAskToken()
     const { replyMarkup, callbackKeys } = buildInlineKeyboard(token, payload.buttons || [])
     indexCallbacks(this.callbackIndex, callbackKeys, token)
-    await adapter.sendTo(target.chatId, { text: payload.text, replyMarkup }, { threadId: target.threadId })
+    try {
+      await adapter.sendTo(target.chatId, { text: payload.text, replyMarkup }, { threadId: target.threadId })
+    } catch (err) {
+      // Never leave stale callback keys pointing at an unresolvable ask.
+      releaseCallbacks(this.callbackIndex, callbackKeys)
+      if (isTopicGoneError(err)) {
+        this.logger?.warn?.(`messengerAsk: topic gone for ${target.platform}:${target.chatId}:${target.threadId} — ask aborted (chat/topic deleted)`)
+        throw new Error('messenger.ask: chat or topic was deleted')
+      }
+      throw err
+    }
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pendingAsks.delete(token)

package/lib/telegram-errors.js

@@ -0,0 +1,41 @@
+// Network error classification for Telegram sends (mirrors Hermes adapter policy).
+//
+// The key distinction: some network failures mean the request NEVER left the
+// process (connect/pool timeout, ECONNRESET before send) → resending is safe.
+// Others (a generic timeout after the request may have reached Telegram) could
+// duplicate a message if we resend → do NOT retry.
+
+function rootCause(err) {
+  let e = err
+  let depth = 0
+  while (e && e.cause && e.cause !== e && depth < 10) {
+    e = e.cause
+    depth++
+  }
+  return e || err
+}
+
+// True when a resend cannot duplicate a message: the request did not reach Telegram.
+export function isResendSafeNetworkError(err) {
+  const c = rootCause(err)
+  const msg = String(c?.message || err?.message || '').toLowerCase()
+  if (/not sent to telegram|connect timeout|und_err_connect|econnreset|enotfound|econnrefused|ECONNRESET|ENOTFOUND|ECONNREFUSED/i.test(msg)) {
+    return true
+  }
+  // undici PoolTimeout message: "Request was *not* sent to Telegram."
+  if (/pool timeout|request was \*?not\*? sent/i.test(msg)) return true
+  return false
+}
+
+// True for a 409 from getUpdates: a second bot instance polls the same token.
+export function isPollingConflict(err) {
+  const msg = String(err?.message || '').toLowerCase()
+  return /terminated by other getupdates request|another bot instance is running|getupdates.*conflict|conflict.*getupdates/i.test(msg)
+}
+
+// True when the target chat/topic no longer exists (deleted/closed/upgraded).
+// Such sends should not be retried and any pending ask binding must be pruned.
+export function isTopicGoneError(err) {
+  const msg = String(err?.message || '').toLowerCase()
+  return /thread not found|message thread not found|topic[_ ]?(not found|closed|deleted)|chat (not found|was (upgraded|deleted))|group chat was (upgraded|deleted)/i.test(msg)
+}

package/lib/telegram-format.js

@@ -7,6 +7,105 @@ export function escapeHtml(text) {
 
 const PH = '\uE000'
 
+// Render inline markdown (bold/italic/code/links) inside already-HTML-escaped text.
+function renderInline(t) {
+  let s = escapeHtml(t)
+  s = s.replace(/\*\*([^*\n]+)\*\*/g, '<b>$1</b>')
+  s = s.replace(/`([^`\n]+)`/g, '<code>$1</code>')
+  s = s.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_, label, url) => `<a href="${escapeHtml(url)}">${label}</a>`)
+  s = s.replace(/(^|[^*])\*([^*\n]+)\*(?!\*)/g, '$1<i>$2</i>')
+  return s
+}
+
+function splitRow(line) {
+  let s = line.trim()
+  if (s.startsWith('|')) s = s.slice(1)
+  if (s.endsWith('|')) s = s.slice(0, -1)
+  return s.split('|').map((c) => c.trim())
+}
+
+function isTableDelimiter(line) {
+  const s = line.trim()
+  if (!s.startsWith('|') || !s.endsWith('|')) return false
+  const cells = s.split('|').slice(1, -1)
+  return cells.length > 0 && cells.every((c) => /^:?-+:?$/.test(c.trim()))
+}
+
+// GFM pipe tables → bold heading + bullet rows (Telegram HTML has no table syntax).
+function convertTables(text, stash) {
+  const lines = text.split('\n')
+  const out = []
+  let i = 0
+  while (i < lines.length) {
+    const line = lines[i]
+    if (line.includes('|') && i + 1 < lines.length && isTableDelimiter(lines[i + 1])) {
+      const headers = splitRow(line)
+      const rows = []
+      let j = i + 2
+      while (j < lines.length && lines[j].includes('|') && !isTableDelimiter(lines[j])) {
+        rows.push(splitRow(lines[j]))
+        j++
+      }
+      let blocks
+      if (headers.length === 2) {
+        // key/value table → bullet list, no separate heading row
+        blocks = rows.map((row) => `• <b>${renderInline(row[0] || '')}</b>: ${renderInline(row[1] || '')}`)
+      } else {
+        blocks = rows.map((row) => {
+          const heading = renderInline(row[0] || '')
+          const bullets = headers
+            .slice(1)
+            .map((h, idx) => {
+              const val = (row[idx + 1] || '').trim()
+              if (!val) return null
+              return `• ${renderInline(h)}: ${renderInline(val)}`
+            })
+            .filter(Boolean)
+          return bullets.length ? `<b>${heading}</b>\n${bullets.join('\n')}` : `<b>${heading}</b>`
+        })
+      }
+      out.push(stash(blocks.join('\n\n')))
+      i = j
+      continue
+    }
+    out.push(line)
+    i++
+  }
+  return out.join('\n')
+}
+
+// GFM task lists → checkbox glyphs.
+function convertTaskLists(text, stash) {
+  const lines = text.split('\n')
+  const out = []
+  let buf = []
+  const flush = () => {
+    if (buf.length) {
+      out.push(stash(buf.join('\n')))
+      buf = []
+    }
+  }
+  for (const line of lines) {
+    const m = line.match(/^(\s*)[-*]\s+\[([ xX])\]\s+(.*)$/)
+    if (m) {
+      buf.push(`${m[1]}${m[2].toLowerCase() === 'x' ? '☑' : '☐'} ${renderInline(m[3])}`)
+    } else {
+      flush()
+      out.push(line)
+    }
+  }
+  flush()
+  return out.join('\n')
+}
+
+// <details><summary>..</summary>..</details> → bold summary + body (no native collapse in HTML).
+function convertDetails(text, stash) {
+  return text.replace(
+    /<details\b[^>]*>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gi,
+    (_, summary, body) => stash(`<b>${renderInline(summary.trim())}</b>\n${renderInline(body.trim())}`),
+  )
+}
+
 /** Convert common Markdown from LLM replies to Telegram HTML parse_mode. */
 export function markdownToTelegramHtml(markdown) {
   let text = String(markdown ?? '')
@@ -20,6 +119,9 @@ export function markdownToTelegramHtml(markdown) {
 
   text = text.replace(/```([\s\S]*?)```/g, (_, code) => stash(`<pre><code>${escapeHtml(code.replace(/^\n/, '').replace(/\n$/, ''))}</code></pre>`))
   text = text.replace(/`([^`\n]+)`/g, (_, code) => stash(`<code>${escapeHtml(code)}</code>`))
+  text = convertTables(text, stash)
+  text = convertDetails(text, stash)
+  text = convertTaskLists(text, stash)
   text = escapeHtml(text)
   text = text.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_, label, url) => `<a href="${escapeHtml(url)}">${label}</a>`)
   text = text.replace(/\*\*([^*\n]+)\*\*/g, '<b>$1</b>')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-messenger-gateway",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Telegram messenger bridge for DeepSeek Harness: sessions, steer, homes, inline asks, notify bridge, and optional TTS voice notes.",
   "license": "MIT",
   "type": "module",