@goodandready/dsh-messenger-gateway 0.3.22 → 0.4.0

package/lib/integrations.js

@@ -37,4 +37,4 @@ export async function speakText(baseUrl, text, signal) {
     mime: data.mime || 'audio/mpeg',
     provider: data.provider,
   }
-}
+}

package/lib/media.js

@@ -40,14 +40,6 @@ export function classifyDocument(ext, mime) {
   return 'unsupported'
 }
 
-export function mediaKindOf(path) {
-  const ext = extname(path).toLowerCase()
-  if (IMAGE_EXT_TO_MIME[ext]) return 'photo'
-  if (['.ogg', '.opus', '.oga'].includes(ext)) return 'voice'
-  if (['.mp3', '.m4a', '.wav', '.flac'].includes(ext)) return 'audio'
-  return 'document'
-}
-
 export function safeName(name) {
   return String(name || 'file').replace(/[^\w.\- ]/g, '_').slice(0, 120) || 'file'
 }
@@ -65,4 +57,4 @@ export function cacheName(prefix, ext, name) {
   return display ? `${base}-${display}${ext || ''}` : `${base}${ext || ''}`
 }
 
-export { basename }
+export { basename }

package/lib/models.js

@@ -20,11 +20,14 @@ export async function listModelCatalog(ctx, fallback = {}) {
             pId,
             (models || []).map((m) => ({ id: m.id || m, name: m.name || m.id || m }))
           )
-        } catch {
+        } catch (err) {
+          /* safe fallback to empty list when provider cannot list models */
           result.modelsByProvider.set(pId, [])
         }
       }
-    } catch {}
+    } catch (err) {
+      /* safe fallback when ctx.llm.listProviders is unavailable or throws */
+    }
   }
 
   // 2. If no providers from ctx.llm, check settings / fallback
@@ -117,4 +120,4 @@ export function buildModelsKeyboard(providerId, models, currentModel, page = 0,
   rows.push([{ text: '🔙 Back to providers', callback_data: 'mdl:back' }])
 
   return { inline_keyboard: rows, page: curPage, totalPages }
-}
+}

package/lib/outbound.js

@@ -110,4 +110,4 @@ export async function buildOutboundFiles(ctx, baseUrl, collector, opts = {}) {
     }
   }
   return files
-}
+}

package/lib/pairing.js

@@ -19,25 +19,29 @@ function writeJsonAtomicSync(filePath, data) {
     writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf8')
     renameSync(tmpPath, filePath)
   } catch (err) {
-    try { unlinkSync(tmpPath) } catch {}
+    try { unlinkSync(tmpPath) } catch { /* safe best-effort temp file cleanup */ }
     throw err
   }
 }
 
-export function createPairingStore(filePath) {
+export function createPairingStore(filePath, { logger } = {}) {
   const state = { pending: {}, /** @type {number[]} */ approved: [] }
   if (filePath && existsSync(filePath)) {
     try {
       const raw = JSON.parse(readFileSync(filePath, 'utf8'))
       if (Array.isArray(raw.approved)) state.approved = raw.approved.map(Number).filter(Number.isFinite)
       if (raw.pending && typeof raw.pending === 'object') state.pending = raw.pending
-    } catch {}
+    } catch (err) {
+      logger?.warn?.('[dsh-messenger-gateway] pairing store read error:', err?.message || err)
+    }
   }
   const persist = () => {
     if (!filePath) return
     try {
       writeJsonAtomicSync(filePath, { approved: state.approved, pending: state.pending })
-    } catch {}
+    } catch (err) {
+      logger?.warn?.('[dsh-messenger-gateway] pairing store persist error:', err?.message || err)
+    }
   }
   const prune = () => {
     const now = Date.now()

package/lib/personas.js

@@ -70,7 +70,7 @@ export function listPersonas() {
   return Object.values(BUILTIN_PERSONAS)
 }
 
-export function createPersonaStore(filePath) {
+export function createPersonaStore(filePath, { logger } = {}) {
   let cache = { personas: {}, presets: {} }
   try {
     const raw = JSON.parse(readFileSync(filePath, 'utf8'))
@@ -81,13 +81,17 @@ export function createPersonaStore(filePath) {
         cache = { personas: raw, presets: {} }
       }
     }
-  } catch {}
+  } catch (err) {
+    if (err?.code !== 'ENOENT') logger?.warn?.('[dsh-messenger-gateway] personas load error:', err?.message || err)
+  }
 
   function save() {
     try {
       mkdirSync(dirname(filePath), { recursive: true })
       writeFileSync(filePath, JSON.stringify(cache, null, 2), 'utf8')
-    } catch {}
+    } catch (err) {
+      logger?.warn?.('[dsh-messenger-gateway] personas save error:', err?.message || err)
+    }
   }
 
   function makeKey(chatId, threadId = 0) {
@@ -148,4 +152,4 @@ export function createPersonaStore(filePath) {
       return { ...cache }
     },
   }
-}
+}

package/lib/photos.js

@@ -28,4 +28,4 @@ export function photoOnlyHint(attachments, userText) {
   if (!photos.length) return ''
   if (photos.length === 1) return '[User attached a photo]'
   return `[User attached ${photos.length} photos]`
-}
+}

package/lib/scheduler.js

@@ -1,160 +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) {
-  let tasks = []
-  let loaded = false
-  let timer = null
-
-  async function load() {
-    try {
-      const raw = await readFile(filePath, 'utf8')
-      tasks = JSON.parse(raw)
-    } catch {
-      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 {}
-  }
-
-  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 {}
-      }
-    }
-
-    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,
+  }
 }