@goodandready/dsh-messenger-gateway 0.4.3 → 0.4.5

package/lib/gateway.js

@@ -1,30 +1,28 @@
-import { readFile } from 'node:fs/promises'
 import { randomUUID } from 'node:crypto'
-import { join, dirname, resolve } from 'node:path'
+import { join } from 'node:path'
 import { homedir } from 'node:os'
-import { fileURLToPath } from 'node:url'
 import { installModelSelection } from '@deepseek-ai/dsh-agent'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import { SessionId } from '@deepseek-ai/dsh-session'
 import createAdapters from './adapters/index.js'
-import { transcribeVoice } from './integrations.js'
-import { attachInboundPhoto, photoOnlyHint } from './photos.js'
-import { chatKey, sessionKey } from './topics.js'
-import { resolveNamedHome } from './homes.js'
+import { sessionKey } from './topics.js'
+import { resolveNamedHome, listHomes } from './homes.js'
+import { assistantText } from './text.js'
+import { collectAssistantParts } from './outbound.js'
+import { extractTextDelta, extractToolName } from './stream.js'
 import { createVoicePrefs } from './voice-prefs.js'
 import { executeMessengerAsk, releaseCallbacks, rejectPendingAsk } from './ask.js'
 import { createPersonaStore, BUILTIN_PERSONAS } from './personas.js'
 import { formatAlertMessage, resolveAlertTarget } from './alerts.js'
 import { createScheduler } from './scheduler.js'
-import { getStoredModelSelection } from './models.js'
 import { createPairingStore } from './pairing.js'
 import { isTopicGoneError } from './telegram-errors.js'
 import { ensureContentArray } from './content-guard.js'
 import { ApiHealthTracker } from './api-health.js'
 import { t } from './locales/index.js'
-import { handleGatewayCommand, releaseChatTurn } from './gateway-commands.js'
+import { handleGatewayCommand } from './gateway-commands.js'
 import { handleGatewayCallback } from './gateway-callbacks.js'
-import { runGatewayTurn, buildUserContent, answerApproval, whenIdleWithTimeout } from './gateway-turn.js'
+import { runGatewayTurn, buildUserContent, answerApproval } from './gateway-turn.js'
 import {
   collectDynamicSkills, syncTelegramCommands,
   mirrorSessionToForumTopic, relayTurnToForumMirror,
@@ -521,7 +519,13 @@ export class Gateway {
     for (const [key, chat] of this.chats) {
       if (!chat.turnActive && now - chat.lastUsed > timeout) {
         if (chat.agent?.session?.id) {
-          this.sessionToChat.delete(String(chat.agent.session.id))
+          const sid = String(chat.agent.session.id)
+          this.sessionToChat.delete(sid)
+          const threadInfo = this.sessionToThread.get(sid)
+          if (threadInfo) {
+            this.threadToSession.delete(`${threadInfo.chatId}:${threadInfo.threadId}`)
+            this.sessionToThread.delete(sid)
+          }
         }
         this.chats.delete(key)
         chat.dispose().catch(() => {})

package/lib/http.js

@@ -13,10 +13,23 @@ export function writeJson(res, status, body) {
 }
 
 export function isTrustedSettingsRequest(req) {
-  const origin = String(req.headers?.origin || '')
   const host = String(req.headers?.host || '')
-  if (!origin || !host) return false
-  try { return new URL(origin).host === host } catch { return false }
+  if (!host) return false
+
+  const origin = String(req.headers?.origin || '')
+  if (origin) {
+    try { return new URL(origin).host === host } catch { return false }
+  }
+
+  const secFetchSite = String(req.headers?.['sec-fetch-site'] || '').toLowerCase()
+  if (secFetchSite === 'same-origin') return true
+
+  const referer = String(req.headers?.referer || '')
+  if (referer) {
+    try { return new URL(referer).host === host } catch { return false }
+  }
+
+  return false
 }
 
 export function timingSafeCompare(a, b) {

package/lib/index.js

@@ -378,15 +378,19 @@ export function apply(ctx, config) {
         return writeJson(res, 400, { ok: false, error: 'invalid json' })
       }
 
-      const expectedSecret = source().webhooks?.secret
-      if (expectedSecret) {
-        const authHeader = req.headers?.authorization || ''
-        const bearer = authHeader.startsWith('Bearer ') ? authHeader.slice(7).trim() : ''
-        const tokenHeader = req.headers?.['x-webhook-secret'] || ''
-        const provided = bearer || tokenHeader || payload.secret
-        if (provided !== expectedSecret) {
-          return writeJson(res, 401, { ok: false, error: 'unauthorized' })
-        }
+      if (source().webhooks?.enabled === false) {
+        return writeJson(res, 404, { ok: false, error: 'webhooks disabled' })
+      }
+      const expectedSecret = String(source().webhooks?.secret || '').trim()
+      if (!expectedSecret) {
+        return writeJson(res, 403, { ok: false, error: 'webhook secret not configured' })
+      }
+      const authHeader = req.headers?.authorization || ''
+      const bearer = authHeader.startsWith('Bearer ') ? authHeader.slice(7).trim() : ''
+      const tokenHeader = req.headers?.['x-webhook-secret'] || ''
+      const provided = bearer || tokenHeader || payload.secret
+      if (!timingSafeCompare(provided, expectedSecret)) {
+        return writeJson(res, 401, { ok: false, error: 'unauthorized' })
       }
 
       const { target, text, home, chatId, threadId, platform = 'telegram', files } = payload

package/lib/models.js

@@ -1,13 +1,33 @@
 export const MODEL_PAGE_SIZE = 10
 
-export async function listModelCatalog(ctx, fallback = {}) {
+let catalogCache = new WeakMap()
+
+export function clearModelCatalogCache() {
+  catalogCache = new WeakMap()
+}
+
+export async function listModelCatalog(ctx, fallback = {}, options = {}) {
+  const llm = ctx?.get?.('llm') || ctx?.llm
+  const ttlMs = typeof options.ttlMs === 'number' ? options.ttlMs : 60_000
+  const bypass = Boolean(options.bypassCache)
+  const now = Date.now()
+
+  if (llm && typeof llm === 'object' && !bypass) {
+    const cached = catalogCache.get(llm)
+    if (cached && (now - cached.timestamp < ttlMs)) {
+      return {
+        providers: [...cached.providers],
+        modelsByProvider: new Map(cached.modelsByProvider),
+      }
+    }
+  }
+
   const result = {
     providers: [],
     modelsByProvider: new Map(),
   }
 
   // 1. Try ctx.llm if available
-  const llm = ctx?.get?.('llm') || ctx?.llm
   if (llm?.listProviders) {
     try {
       const providers = await llm.listProviders()
@@ -25,6 +45,13 @@ export async function listModelCatalog(ctx, fallback = {}) {
           result.modelsByProvider.set(pId, [])
         }
       }
+      if (llm && typeof llm === 'object' && result.providers.length > 0) {
+        catalogCache.set(llm, {
+          timestamp: now,
+          providers: result.providers,
+          modelsByProvider: new Map(result.modelsByProvider),
+        })
+      }
     } catch (err) {
       /* safe fallback when ctx.llm.listProviders is unavailable or throws */
     }

package/lib/scheduler.js

@@ -1,170 +1,170 @@
-import { readFile } from 'node:fs/promises'
-import { randomUUID } from 'node:crypto'
-import { writeJsonAtomic } from './storage-atomic.js'
-
-export function parseRelativeTime(input) {
-  if (!input) return null
-  const raw = String(input).trim().toLowerCase()
-  const match = /^(\d+)\s*(s|sec|m|min|h|hr|d|day|秒|分|小时|天)?$/i.exec(raw)
-  if (!match) return null
-
-  const val = parseInt(match[1], 10)
-  if (!Number.isFinite(val) || val <= 0) return null
-
-  const unit = (match[2] || 'm').toLowerCase()
-  if (['s', 'sec', '秒'].includes(unit)) return val * 1000
-  if (['m', 'min', '分'].includes(unit)) return val * 60 * 1000
-  if (['h', 'hr', '小时'].includes(unit)) return val * 3600 * 1000
-  if (['d', 'day', '天'].includes(unit)) return val * 86400 * 1000
-
-  return null
-}
-
-export function formatRemaining(ms, locale = 'en') {
-  const isZh = String(locale || '').toLowerCase().startsWith('zh')
-  if (ms <= 0) return isZh ? '刚刚' : 'now'
-  const sec = Math.ceil(ms / 1000)
-  if (sec < 60) return isZh ? `${sec}秒` : `${sec}s`
-  const min = Math.ceil(sec / 60)
-  if (min < 60) return isZh ? `${min}分` : `${min}m`
-  const hr = Math.floor(min / 60)
-  const remMin = min % 60
-  if (isZh) return remMin ? `${hr}小时 ${remMin}分` : `${hr}小时`
-  return remMin ? `${hr}h ${remMin}m` : `${hr}h`
-}
-
-export function createScheduler(filePath, onDue, options = {}) {
-  const logger = options?.logger || console
-  let tasks = []
-  let loaded = false
-  let timer = null
-
-  async function load() {
-    try {
-      const raw = await readFile(filePath, 'utf8')
-      tasks = JSON.parse(raw)
-    } catch (err) {
-      if (err?.code !== 'ENOENT') {
-        logger?.debug?.('[dsh-messenger-gateway] scheduler load error:', err?.message || err)
-      }
-      tasks = []
-    }
-    loaded = true
-  }
-
-  const RETENTION_MS = 7 * 86400 * 1000
-
-  async function save() {
-    if (!filePath) return
-    try {
-      const now = Date.now()
-      tasks = tasks.filter((t) => {
-        if (t.status === 'pending') return true
-        const finishTime = t.firedAt || t.createdAt || 0
-        return (now - finishTime) < RETENTION_MS
-      })
-      await writeJsonAtomic(filePath, tasks)
-    } catch (err) {
-      logger?.warn?.('[dsh-messenger-gateway] scheduler save failed:', err?.message || err)
-    }
-  }
-
-  async function checkDue() {
-    if (!loaded) await load()
-    const now = Date.now()
-    const due = tasks.filter((t) => t.status === 'pending' && t.dueAt <= now)
-
-    for (const task of due) {
-      if (task.recurring && Number(task.intervalMs) > 0) {
-        task.dueAt = now + Number(task.intervalMs)
-        task.lastFiredAt = now
-      } else {
-        task.status = 'fired'
-        task.firedAt = now
-      }
-      if (typeof onDue === 'function') {
-        try {
-          await onDue(task)
-        } catch (err) {
-          logger?.warn?.('[dsh-messenger-gateway] scheduler task execution failed:', err?.message || err)
-        }
-      }
-    }
-
-    if (due.length > 0) {
-      await save()
-    }
-  }
-
-  function start(intervalMs = 5000) {
-    if (timer) clearInterval(timer)
-    timer = setInterval(() => {
-      checkDue().catch(() => {})
-    }, intervalMs)
-    timer.unref?.()
-    checkDue().catch(() => {})
-  }
-
-  function stop() {
-    if (timer) {
-      clearInterval(timer)
-      timer = null
-    }
-  }
-
-  async function schedule(taskData) {
-    if (!loaded) await load()
-    const id = taskData.id || randomUUID().slice(0, 8)
-    const task = {
-      id,
-      platform: taskData.platform || 'telegram',
-      chatId: taskData.chatId,
-      threadId: taskData.threadId || 0,
-      userId: taskData.userId,
-      text: taskData.text,
-      prompt: taskData.prompt || taskData.text || '',
-      dueAt: taskData.dueAt,
-      createdAt: Date.now(),
-      status: 'pending',
-      recurring: Boolean(taskData.recurring),
-      intervalMs: taskData.intervalMs || 0,
-      cronExpr: taskData.cronExpr || '',
-    }
-    tasks.push(task)
-    await save()
-    return task
-  }
-
-  async function list(chatId) {
-    if (!loaded) await load()
-    const now = Date.now()
-    return tasks.filter((t) => (chatId ? t.chatId === chatId : true) && t.status === 'pending' && t.dueAt > now)
-  }
-
-  async function listRecurring(chatId) {
-    if (!loaded) await load()
-    return tasks.filter((t) => (chatId ? t.chatId === chatId : true) && t.status === 'pending' && t.recurring)
-  }
-
-  async function cancel(id, chatId) {
-    if (!loaded) await load()
-    const task = tasks.find((t) => t.id === id && (chatId ? t.chatId === chatId : true) && t.status === 'pending')
-    if (!task) return false
-    task.status = 'cancelled'
-    await save()
-    return true
-  }
-
-  return {
-    load,
-    save,
-    start,
-    stop,
-    schedule,
-    list,
-    listRecurring,
-    cancel,
-    checkDue,
-    getTasks: () => tasks,
-  }
+import { readFile } from 'node:fs/promises'
+import { randomUUID } from 'node:crypto'
+import { writeJsonAtomic } from './storage-atomic.js'
+
+export function parseRelativeTime(input) {
+  if (!input) return null
+  const raw = String(input).trim().toLowerCase()
+  const match = /^(\d+)\s*(s|sec|m|min|h|hr|d|day|秒|分|小时|天)?$/i.exec(raw)
+  if (!match) return null
+
+  const val = parseInt(match[1], 10)
+  if (!Number.isFinite(val) || val <= 0) return null
+
+  const unit = (match[2] || 'm').toLowerCase()
+  if (['s', 'sec', '秒'].includes(unit)) return val * 1000
+  if (['m', 'min', '分'].includes(unit)) return val * 60 * 1000
+  if (['h', 'hr', '小时'].includes(unit)) return val * 3600 * 1000
+  if (['d', 'day', '天'].includes(unit)) return val * 86400 * 1000
+
+  return null
+}
+
+export function formatRemaining(ms, locale = 'en') {
+  const isZh = String(locale || '').toLowerCase().startsWith('zh')
+  if (ms <= 0) return isZh ? '刚刚' : 'now'
+  const sec = Math.ceil(ms / 1000)
+  if (sec < 60) return isZh ? `${sec}秒` : `${sec}s`
+  const min = Math.ceil(sec / 60)
+  if (min < 60) return isZh ? `${min}分` : `${min}m`
+  const hr = Math.floor(min / 60)
+  const remMin = min % 60
+  if (isZh) return remMin ? `${hr}小时 ${remMin}分` : `${hr}小时`
+  return remMin ? `${hr}h ${remMin}m` : `${hr}h`
+}
+
+export function createScheduler(filePath, onDue, options = {}) {
+  const logger = options?.logger || console
+  let tasks = []
+  let loaded = false
+  let timer = null
+
+  async function load() {
+    try {
+      const raw = await readFile(filePath, 'utf8')
+      tasks = JSON.parse(raw)
+    } catch (err) {
+      if (err?.code !== 'ENOENT') {
+        logger?.debug?.('[dsh-messenger-gateway] scheduler load error:', err?.message || err)
+      }
+      tasks = []
+    }
+    loaded = true
+  }
+
+  const RETENTION_MS = 7 * 86400 * 1000
+
+  async function save() {
+    if (!filePath) return
+    try {
+      const now = Date.now()
+      tasks = tasks.filter((t) => {
+        if (t.status === 'pending') return true
+        const finishTime = t.firedAt || t.createdAt || 0
+        return (now - finishTime) < RETENTION_MS
+      })
+      await writeJsonAtomic(filePath, tasks)
+    } catch (err) {
+      logger?.warn?.('[dsh-messenger-gateway] scheduler save failed:', err?.message || err)
+    }
+  }
+
+  async function checkDue() {
+    if (!loaded) await load()
+    const now = Date.now()
+    const due = tasks.filter((t) => t.status === 'pending' && t.dueAt <= now)
+
+    for (const task of due) {
+      if (task.recurring && Number(task.intervalMs) > 0) {
+        task.dueAt = now + Number(task.intervalMs)
+        task.lastFiredAt = now
+      } else {
+        task.status = 'fired'
+        task.firedAt = now
+      }
+      if (typeof onDue === 'function') {
+        try {
+          await onDue(task)
+        } catch (err) {
+          logger?.warn?.('[dsh-messenger-gateway] scheduler task execution failed:', err?.message || err)
+        }
+      }
+    }
+
+    if (due.length > 0) {
+      await save()
+    }
+  }
+
+  function start(intervalMs = 5000) {
+    if (timer) clearInterval(timer)
+    timer = setInterval(() => {
+      checkDue().catch(() => {})
+    }, intervalMs)
+    timer.unref?.()
+    checkDue().catch(() => {})
+  }
+
+  function stop() {
+    if (timer) {
+      clearInterval(timer)
+      timer = null
+    }
+  }
+
+  async function schedule(taskData) {
+    if (!loaded) await load()
+    const id = taskData.id || randomUUID().slice(0, 8)
+    const task = {
+      id,
+      platform: taskData.platform || 'telegram',
+      chatId: taskData.chatId,
+      threadId: taskData.threadId || 0,
+      userId: taskData.userId,
+      text: taskData.text,
+      prompt: taskData.prompt || taskData.text || '',
+      dueAt: taskData.dueAt,
+      createdAt: Date.now(),
+      status: 'pending',
+      recurring: Boolean(taskData.recurring),
+      intervalMs: taskData.intervalMs || 0,
+      cronExpr: taskData.cronExpr || '',
+    }
+    tasks.push(task)
+    await save()
+    return task
+  }
+
+  async function list(chatId) {
+    if (!loaded) await load()
+    const now = Date.now()
+    return tasks.filter((t) => (chatId ? t.chatId === chatId : true) && t.status === 'pending' && t.dueAt > now)
+  }
+
+  async function listRecurring(chatId) {
+    if (!loaded) await load()
+    return tasks.filter((t) => (chatId ? t.chatId === chatId : true) && t.status === 'pending' && t.recurring)
+  }
+
+  async function cancel(id, chatId) {
+    if (!loaded) await load()
+    const task = tasks.find((t) => t.id === id && (chatId ? t.chatId === chatId : true) && t.status === 'pending')
+    if (!task) return false
+    task.status = 'cancelled'
+    await save()
+    return true
+  }
+
+  return {
+    load,
+    save,
+    start,
+    stop,
+    schedule,
+    list,
+    listRecurring,
+    cancel,
+    checkDue,
+    getTasks: () => tasks,
+  }
 }

package/package.json

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