@goodandready/dsh-messenger-gateway 0.3.14 → 0.3.19

package/README.md

@@ -104,6 +104,12 @@ In addition to Telegram, outbound messages can be dispatched to Discord and Slac
 - `notifyBridge` — forward non-messenger web session events to a home
 - Bot token is a DSH secret field — never commit it
 
+## Client UI & Settings Card
+
+- Mounted into `settings.plugin.item` on the Plugins tab (`key: dsh-messenger-gateway`).
+- Configuration is managed reactively via `settingsScope.bind({ namespace: 'dsh-messenger-gateway' })` with snapshot status checking (`loading`, `unavailable`, `ready`).
+- Protected dictionary registration: duplicate registration attempts on page reload are safely caught with non-fatal warnings, ensuring the settings card never fails to mount.
+
 ## Requirements
 
 - DeepSeek Harness web (or compatible) profile

package/lib/adapters/telegram.js

@@ -11,7 +11,7 @@ import { normalizeThreadId, telegramThreadParams } from '../topics.js'
 import {
   shouldProcessTelegramMessage, stripBotCommandSuffix,
 } from '../groups.js'
-import { isResendSafeNetworkError, isPollingConflict } from '../telegram-errors.js'
+import { isResendSafeNetworkError, isPollingConflict, isTopicGoneError, computePollBackoffMs } from '../telegram-errors.js'
 
 const API = 'https://api.telegram.org'
 const TELEGRAM_MAX = 4096
@@ -55,6 +55,7 @@ export class TelegramAdapter {
     this.sendRetryMax = 2
     this.sendRetryBaseMs = 400
     this.pollingConflict = false
+    this.pollErrorCount = 0
     this.webhookUrl = String(opts.webhookUrl || '').trim()
     this.webhookSecret = String(opts.webhookSecret || '').trim()
     this.offset = 0
@@ -74,6 +75,7 @@ export class TelegramAdapter {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(params),
+      keepalive: true,
       signal: AbortSignal.timeout(timeoutMs),
     })
     const json = await res.json().catch(() => ({}))
@@ -86,6 +88,7 @@ export class TelegramAdapter {
     const res = await fetch(`${API}/bot${this.token}/${method}`, {
       method: 'POST',
       body: form,
+      keepalive: true,
       signal: AbortSignal.timeout(timeoutMs),
     })
     const json = await res.json().catch(() => ({}))
@@ -116,6 +119,7 @@ export class TelegramAdapter {
   async downloadFile(filePath) {
     const timeoutMs = (this.timeoutSeconds * 1000) + 30000
     const res = await fetch(`${API}/file/bot${this.token}/${filePath}`, {
+      keepalive: true,
       signal: AbortSignal.timeout(timeoutMs),
     })
     if (!res.ok) throw new Error(`telegram download HTTP ${res.status}`)
@@ -181,9 +185,10 @@ export class TelegramAdapter {
     if (this.statusIndicator) this.setStatusIndicator(this.statusOffline).catch(() => {})
   }
 
-  schedulePoll() {
+  schedulePoll(delayMs) {
     if (this.stopped) return
-    this.pollTimer = setTimeout(() => this.poll(), this.pollIntervalMs)
+    const delay = delayMs !== undefined ? delayMs : this.pollIntervalMs
+    this.pollTimer = setTimeout(() => this.poll(), delay)
     this.pollTimer.unref?.()
   }
 
@@ -196,6 +201,7 @@ export class TelegramAdapter {
         allowed_updates: ['message', 'callback_query'],
       })
       this.pollingConflict = false
+    this.pollErrorCount = 0
       for (const update of updates || []) {
         this.offset = Math.max(this.offset, update.update_id + 1)
         await this.dispatchUpdate(update)
@@ -466,12 +472,26 @@ export class TelegramAdapter {
   }
 
   async startStreamMessage(chatId, replyTo, threadId = 0) {
-    const result = await this.call('sendMessage', {
-      chat_id: chatId,
-      text: '…',
-      reply_to_message_id: replyTo,
-      ...telegramThreadParams(threadId),
-    })
+    let result
+    try {
+      result = await this.call('sendMessage', {
+        chat_id: chatId,
+        text: '…',
+        reply_to_message_id: replyTo,
+        ...telegramThreadParams(threadId),
+      })
+    } catch (err) {
+      if (threadId && isTopicGoneError(err)) {
+        this.logger?.warn?.(`telegram stream start topic gone (thread ${threadId}), fallback main chat: ${err.message}`)
+        result = await this.call('sendMessage', {
+          chat_id: chatId,
+          text: '…',
+          reply_to_message_id: replyTo,
+        })
+      } else {
+        throw err
+      }
+    }
     const messageId = result?.message_id
     return {
       messageId,
@@ -511,12 +531,30 @@ export class TelegramAdapter {
     const blob = new Blob([file.bytes])
     const name = safeName(file.name || 'file')
     const isSvg = file.mime === 'image/svg+xml' || (file.name && file.name.toLowerCase().endsWith('.svg'))
-    if (file.kind === 'photo' && !isSvg) { 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.sendWithRetry('sendDocument', form, { multipart: true })
+    const send = (m, f) => this.sendWithRetry(m, f, { multipart: true })
+    const method = (file.kind === 'photo' && !isSvg) ? 'sendPhoto'
+      : (file.kind === 'voice') ? 'sendVoice'
+      : (file.kind === 'audio') ? 'sendAudio'
+      : (file.kind === 'video') ? 'sendVideo'
+      : 'sendDocument'
+    const fieldName = (file.kind === 'photo' && !isSvg) ? 'photo'
+      : (file.kind === 'voice') ? 'voice'
+      : (file.kind === 'audio') ? 'audio'
+      : (file.kind === 'video') ? 'video'
+      : 'document'
+    form.append(fieldName, blob, name)
+    try {
+      return await send(method, form)
+    } catch (err) {
+      if (threadId && isTopicGoneError(err)) {
+        this.logger?.warn?.(`telegram sendMedia topic gone (thread ${threadId}), fallback main chat: ${err.message}`)
+        const fallbackForm = new FormData()
+        fallbackForm.append('chat_id', String(chatId))
+        fallbackForm.append(fieldName, blob, name)
+        return await send(method, fallbackForm)
+      }
+      throw err
+    }
   }
 
   formatOutgoingText(text, payload = {}) {
@@ -547,19 +585,41 @@ export class TelegramAdapter {
       try {
         await this.sendWithRetry('sendMessage', params)
       } catch (err) {
+        if (threadId && isTopicGoneError(err)) {
+          this.logger?.warn?.(`telegram send topic gone (thread ${threadId}), fallback main chat: ${err.message}`)
+          params.message_thread_id = undefined
+          delete params.message_thread_id
+          await this.sendWithRetry('sendMessage', params)
+          continue
+        }
         if (!parseMode) throw err
         this.logger?.warn?.(`telegram HTML send failed, fallback plain: ${err.message}`)
-        await this.call('sendMessage', {
-          chat_id: chatId,
-          text: plainChunks[i] ?? chunks[i],
-          reply_to_message_id: replyTo,
-          reply_markup: i === 0 ? effectiveMarkup : undefined,
-          ...telegramThreadParams(threadId),
-        })
+        try {
+          await this.call('sendMessage', {
+            chat_id: chatId,
+            text: plainChunks[i] ?? chunks[i],
+            reply_to_message_id: replyTo,
+            reply_markup: i === 0 ? effectiveMarkup : undefined,
+            ...telegramThreadParams(threadId),
+          })
+        } catch (err2) {
+          if (threadId && isTopicGoneError(err2)) {
+            this.logger?.warn?.(`telegram plain send topic gone (thread ${threadId}), fallback main chat: ${err2.message}`)
+            await this.call('sendMessage', {
+              chat_id: chatId,
+              text: plainChunks[i] ?? chunks[i],
+              reply_to_message_id: replyTo,
+              reply_markup: i === 0 ? effectiveMarkup : undefined,
+            })
+          } else {
+            throw err2
+          }
+        }
       }
     }
   }
 
+
   async sendReply(chatId, replyTo, payload, threadId = 0) {
     const body = typeof payload === 'string' ? { text: payload } : (payload || {})
     const files = Array.isArray(body.files) ? body.files : []
@@ -579,6 +639,46 @@ export class TelegramAdapter {
     return this.sendReply(chatId, undefined, payload, normalizeThreadId(opts.threadId))
   }
 
+  async probeHealth(timeoutMs = 10000) {
+    if (!this.token) {
+      return { ok: false, error: 'Telegram bot token is empty' }
+    }
+    const start = Date.now()
+    try {
+      const res = await fetch(`${API}/bot${this.token}/getMe`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+        signal: AbortSignal.timeout(Math.max(1000, Number(timeoutMs) || 10000)),
+      })
+      const latencyMs = Date.now() - start
+      const json = await res.json().catch(() => ({}))
+      if (!res.ok || json.ok === false) {
+        return {
+          ok: false,
+          latencyMs,
+          error: json.description || `HTTP ${res.status}`,
+        }
+      }
+      const me = json.result || {}
+      this.botId = Number(me.id) || this.botId
+      this.botUsername = String(me.username || this.botUsername)
+      return {
+        ok: true,
+        latencyMs,
+        botId: this.botId,
+        botUsername: this.botUsername,
+        firstName: me.first_name || '',
+      }
+    } catch (err) {
+      return {
+        ok: false,
+        latencyMs: Date.now() - start,
+        error: err instanceof Error ? err.message : String(err),
+      }
+    }
+  }
+
   async createForumTopic(chatId, name, opts = {}) {
     return this.call('createForumTopic', {
       chat_id: chatId,