@goodandready/dsh-messenger-gateway 0.4.10 → 0.4.12

package/lib/ask.js

@@ -56,7 +56,9 @@ export function buildInlineKeyboard(token, buttons) {
 
 export function normalizeAskOptions(options = []) {
   if (Array.isArray(options)) {
-    const flat = options.flat ? options.flat() : [].concat(...options)
+    const flat = typeof options.flat === 'function'
+      ? options.flat()
+      : options.reduce((acc, item) => acc.concat(item), [])
     return flat.map((opt, i) => {
       if (typeof opt === 'string') return { id: String(i + 1), text: opt, selected: false }
       const id = String(opt?.id ?? opt?.buttonId ?? i + 1).trim()

package/lib/client.js

@@ -17,6 +17,15 @@ window.__ModuleLoader__.load({
     const ROW_ID = 'dsh-messenger-gateway'
     const ROW_CONFIG_KEY = PKG + '#' + ROW_ID
 
+    function timeoutSignal(ms) {
+      if (typeof AbortSignal?.timeout === 'function') {
+        return AbortSignal.timeout(ms)
+      }
+      const controller = new AbortController()
+      setTimeout(() => controller.abort(new Error('TimeoutError')), ms)
+      return controller.signal
+    }
+
     const en = {
       title: 'Messenger gateway',
       description: 'Telegram bot: text, voice, photos, documents, and interactive asks.',
@@ -593,7 +602,7 @@ window.__ModuleLoader__.load({
 
       const loadStatus = React.useCallback(async () => {
         try {
-          const res = await fetch(`${ROUTE_PREFIX}/status`, { cache: 'no-store' })
+          const res = await fetch(`${ROUTE_PREFIX}/status`, { cache: 'no-store', signal: timeoutSignal(10000) })
           const data = await res.json().catch(() => ({}))
           if (res.ok && data.ok) {
             setStatus(data)
@@ -605,7 +614,7 @@ window.__ModuleLoader__.load({
 
       const loadPairing = React.useCallback(async () => {
         try {
-          const res = await fetch(`${ROUTE_PREFIX}/pairing`, { credentials: 'same-origin', cache: 'no-store' })
+          const res = await fetch(`${ROUTE_PREFIX}/pairing`, { credentials: 'same-origin', cache: 'no-store', signal: timeoutSignal(10000) })
           const data = await res.json().catch(() => ({}))
           if (res.ok && data.ok) setPending(Array.isArray(data.pending) ? data.pending : [])
         } catch (err) {
@@ -626,7 +635,7 @@ window.__ModuleLoader__.load({
       const loadUpdateStatus = React.useCallback(async () => {
         setUpdateState((s) => ({ ...s, checking: true, error: '' }))
         try {
-          const res = await fetch(`${ROUTE_PREFIX}/update`, { cache: 'no-store' })
+          const res = await fetch(`${ROUTE_PREFIX}/update`, { cache: 'no-store', signal: timeoutSignal(15000) })
           const data = await res.json().catch(() => ({}))
           if (res.ok && data.ok) {
             setUpdateState((s) => ({
@@ -655,6 +664,7 @@ window.__ModuleLoader__.load({
               'Content-Type': 'application/json',
               'x-dsh-plugin-update': '1',
             },
+            signal: timeoutSignal(60000),
           })
           const data = await res.json().catch(() => ({}))
           if (!res.ok || !data.ok) throw new Error(data.error || `HTTP ${res.status}`)
@@ -689,6 +699,7 @@ window.__ModuleLoader__.load({
             credentials: 'same-origin',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({ timeoutMs: 8000 }),
+            signal: timeoutSignal(15000),
           })
           const data = await res.json().catch(() => ({}))
           if (!data.ok) throw new Error(data.error || `HTTP ${res.status}`)
@@ -1348,6 +1359,7 @@ window.__ModuleLoader__.load({
                                   credentials: 'same-origin',
                                   headers: { 'Content-Type': 'application/json' },
                                   body: JSON.stringify({ code: row.code }),
+                                  signal: timeoutSignal(15000),
                                 })
                                 const data = await res.json()
                                 if (!res.ok || !data.ok) throw new Error(data.error || res.status)
@@ -1376,6 +1388,7 @@ window.__ModuleLoader__.load({
                                   credentials: 'same-origin',
                                   headers: { 'Content-Type': 'application/json' },
                                   body: JSON.stringify({ code: row.code }),
+                                  signal: timeoutSignal(15000),
                                 })
                                 const data = await res.json()
                                 if (!res.ok || !data.ok) throw new Error(data.error || res.status)

package/lib/config.js

@@ -9,6 +9,7 @@ const HomeEntry = z.object({
 export const PluginConfig = z.object({
   enabled: z.boolean().volatile().default(true),
   internalBaseURL: z.string().volatile().default('http://127.0.0.1:3080'),
+  defaultLocale: z.union([z.const('en'), z.const('zh')]).default('en').description('Default language for bot messages and notifications (en, zh)'),
   telegram: z.object({
     enabled: z.boolean().default(false),
     botToken: z.string().role('secret').default(''),

package/lib/documents.js

@@ -1,4 +1,4 @@
-import { readFile } from 'node:fs/promises'
+import { open } from 'node:fs/promises'
 import { extname } from 'node:path'
 import { inflateRawSync } from 'node:zlib'
 
@@ -132,7 +132,36 @@ export async function parseDocument(filePath, opts = {}) {
   const ext = extname(filePath).toLowerCase()
 
   try {
-    const rawBuffer = await readFile(filePath)
+    const handle = await open(filePath, 'r')
+    let rawBuffer
+    let truncated = false
+    let originalLength = 0
+
+    try {
+      const st = await handle.stat()
+      originalLength = st.size
+
+      if (TEXT_INJECT_EXTS.has(ext)) {
+        const toRead = Math.min(st.size, maxBytes)
+        const buf = Buffer.alloc(toRead)
+        const { bytesRead } = await handle.read(buf, 0, toRead, 0)
+        rawBuffer = buf.subarray(0, bytesRead)
+        truncated = st.size > toRead
+      } else if (ext === '.pdf' || ext === '.docx') {
+        const maxBinary = Math.max(maxBytes * 4, 10 * 1024 * 1024)
+        if (st.size > maxBinary) {
+          return { parsed: false, error: `File size (${st.size} bytes) exceeds safety parse limit` }
+        }
+        const buf = Buffer.alloc(st.size)
+        const { bytesRead } = await handle.read(buf, 0, st.size, 0)
+        rawBuffer = buf.subarray(0, bytesRead)
+      } else {
+        return { parsed: false, type: 'unsupported' }
+      }
+    } finally {
+      await handle.close()
+    }
+
     let text = ''
     let parsedType = 'text'
 
@@ -145,15 +174,11 @@ export async function parseDocument(filePath, opts = {}) {
     } else if (TEXT_INJECT_EXTS.has(ext)) {
       parsedType = ext.slice(1)
       text = rawBuffer.toString('utf8')
-    } else {
-      return { parsed: false, type: 'unsupported' }
     }
 
     text = text.trim()
     if (!text) return { parsed: false, type: parsedType }
 
-    const originalLength = text.length
-    let truncated = false
     if (text.length > maxBytes) {
       text = text.slice(0, maxBytes)
       truncated = true
@@ -164,9 +189,10 @@ export async function parseDocument(filePath, opts = {}) {
       type: parsedType,
       text,
       truncated,
-      originalLength,
+      originalLength: originalLength || text.length,
     }
   } catch (err) {
     return { parsed: false, error: err.message }
   }
 }
+

package/lib/gateway.js

@@ -182,40 +182,55 @@ export class Gateway {
     }
   }
 
-  async start() {
-    this.disposeListener = this.ctx.on('session/event', (session, event) => {
-      if (this.config.telegram?.forumMirrorEnabled) {
-        if (event.type === 'turn/start' || event.type === 'session/create') {
-          this.mirrorSessionToForumTopic(session).catch?.((e) => this.logger?.debug?.('mirror error:', e?.message || e))
-        } else if (event.type === 'turn/end') {
-          this.relayTurnToForumMirror(session, event).catch?.((e) => this.logger?.debug?.('relay mirror error:', e?.message || e))
-        }
+  handleHostEvent(session, event) {
+    if (!session || !event) return
+    if (this.config.telegram?.forumMirrorEnabled) {
+      if (event.type === 'turn/start' || event.type === 'session/create') {
+        this.mirrorSessionToForumTopic(session).catch?.((e) => this.logger?.debug?.('mirror error:', e?.message || e))
+      } else if (event.type === 'turn/end') {
+        this.relayTurnToForumMirror(session, event).catch?.((e) => this.logger?.debug?.('relay mirror error:', e?.message || e))
       }
+    }
 
-      const collector = this.pending.get(session.id)
-      if (!collector) return
-      if (event.type === 'assistant/message') {
-        const msg = event.data.message
-        const text = assistantText(msg)
-        if (text) collector.lastText = text
-        const extra = collectAssistantParts(msg)
-        for (const img of extra.images) collector.images.push(img)
-      } else if (event.type === 'assistant/chunk') {
-        const delta = extractTextDelta(event.data?.chunk)
-        if (delta) {
-          collector.streamText = (collector.streamText || '') + delta
-          collector.onStream?.(collector.streamText, collector.toolName)
-        }
-      } else if (event.type === 'tool/call') {
-        collector.toolName = extractToolName(event.data) || collector.toolName
-        collector.onStream?.(collector.streamText || '', collector.toolName)
-      } else if (event.type === 'tool/result') {
-        collector.toolName = ''
-        collector.onStream?.(collector.streamText || '', '')
-      } else if (event.type === 'turn/end') {
-        collector.reason = event.data.reason
+    const collector = this.pending.get(session.id)
+    if (!collector) return
+    if (event.type === 'assistant/message') {
+      const msg = event.data?.message || event.data
+      const text = assistantText(msg)
+      if (text) collector.lastText = text
+      const extra = collectAssistantParts(msg)
+      for (const img of extra.images) collector.images.push(img)
+    } else if (event.type === 'assistant/chunk') {
+      const delta = extractTextDelta(event.data?.chunk || event.data)
+      if (delta) {
+        collector.streamText = (collector.streamText || '') + delta
+        collector.onStream?.(collector.streamText, collector.toolName)
       }
-    })
+    } else if (event.type === 'tool/call') {
+      collector.toolName = extractToolName(event.data) || collector.toolName
+      collector.onStream?.(collector.streamText || '', collector.toolName)
+    } else if (event.type === 'tool/result') {
+      collector.toolName = ''
+      collector.onStream?.(collector.streamText || '', '')
+    } else if (event.type === 'turn/end') {
+      collector.reason = event.data?.reason || event.data
+    }
+  }
+
+  async start() {
+    const onHost = (session, event) => this.handleHostEvent(session, event)
+    const unsubs = [
+      this.ctx.on('session/event', onHost),
+      this.ctx.on('turn/end', (session, data) => onHost(session, { type: 'turn/end', data })),
+      this.ctx.on('turn/start', (session, data) => onHost(session, { type: 'turn/start', data })),
+      this.ctx.on('assistant/message', (session, message) => onHost(session, { type: 'assistant/message', data: { message } })),
+      this.ctx.on('assistant/chunk', (session, chunk) => onHost(session, { type: 'assistant/chunk', data: { chunk } })),
+    ]
+    this.disposeListener = () => {
+      for (const un of unsubs) {
+        if (typeof un === 'function') un()
+      }
+    }
     const adapters = createAdapters({
       config: this.config,
       onMessage: (input) => this.handleMessage(input),

package/lib/index.js

@@ -149,7 +149,57 @@ export function apply(ctx, config) {
   const turnStarts = new Map()
   const getWebServer = () => ctx.get?.('webServer') || ctx.webServer
 
+  let webhookRouteDispose = null
+  let currentWebhookPath = ''
+
+  const webhookPath = () => {
+    const p = String(source().telegram?.webhookPath || '').trim()
+    return p || '/dsh-messenger-gateway/telegram/webhook'
+  }
+
+  const syncWebhookRoute = () => {
+    const targetPath = webhookPath()
+    if (targetPath === currentWebhookPath && webhookRouteDispose) return
+    if (typeof webhookRouteDispose === 'function') {
+      try { webhookRouteDispose() } catch (e) { /* ignore */ }
+      webhookRouteDispose = null
+    }
+    currentWebhookPath = targetPath
+    const ws = getWebServer()
+    if (!ws?.register) return
+    webhookRouteDispose = ws.register({
+      kind: 'exact',
+      path: targetPath,
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
+        const cfg = source().telegram || {}
+        if (cfg.transport !== 'webhook') return writeJson(res, 404, { ok: false, error: 'webhook transport disabled' })
+        const secret = String(cfg.webhookSecret || '').trim()
+        if (!secret) {
+          return writeJson(res, 403, { ok: false, error: 'webhook secret not configured' })
+        }
+        const hdr = String(req.headers['x-telegram-bot-api-secret-token'] || '')
+        if (!timingSafeCompare(hdr, secret)) {
+          return writeJson(res, 403, { ok: false, error: 'bad secret' })
+        }
+        const gw = getGw()
+        const adapter = gw?.getAdapter?.('telegram')
+        if (!adapter?.handleWebhookUpdate) return writeJson(res, 503, { ok: false, error: 'telegram adapter unavailable' })
+        const parsed = await readJsonSafe(req, res, 2_097_152)
+        if (!parsed.ok) return
+        const update = parsed.data
+        try {
+          await adapter.handleWebhookUpdate(update)
+          writeJson(res, 200, { ok: true })
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err.message })
+        }
+      },
+    })
+  }
+
   const sync = () => {
+    syncWebhookRoute()
     if (gateway) { gateway.stop(); gateway = undefined }
     const effective = source()
     if (effective.enabled === false) return
@@ -292,51 +342,69 @@ export function apply(ctx, config) {
       const gw = getGw()
       if (gw) gw.syncTelegramCommands().catch((err) => ctx.logger?.debug?.(`sync telegram commands on skills change: ${err?.message || err}`))
     }
-    const unbind = ctx.on('skills/change', onSkillsChange)
-    return () => { if (typeof unbind === 'function') unbind() }
+    const unbind1 = ctx.on('skills/change', onSkillsChange)
+    const unbind2 = ctx.on('skills/updated', onSkillsChange)
+    const unbind3 = ctx.on('skills/update', onSkillsChange)
+    return () => {
+      if (typeof unbind1 === 'function') unbind1()
+      if (typeof unbind2 === 'function') unbind2()
+      if (typeof unbind3 === 'function') unbind3()
+    }
   }, 'dsh-messenger-gateway: dynamic skills sync')
 
   // Notify → Telegram home bridge (non-msgw sessions only)
-  ctx.effect(() => ctx.on('session/event', (session, event) => {
-    const cfg = source().telegram?.notifyBridge
-    if (!cfg?.enabled) return
-    if (event.type === 'turn/start') {
-      const now = Date.now()
-      if (turnStarts.size > 50) {
-        for (const [sid, ts] of turnStarts.entries()) {
-          if (now - ts > 7_200_000) turnStarts.delete(sid)
+  ctx.effect(() => {
+    const handleNotify = (session, event) => {
+      if (!session || !event) return
+      const cfg = source().telegram?.notifyBridge
+      if (!cfg?.enabled) return
+      if (event.type === 'turn/start') {
+        const now = Date.now()
+        if (turnStarts.size > 50) {
+          for (const [sid, ts] of turnStarts.entries()) {
+            if (now - ts > 7_200_000) turnStarts.delete(sid)
+          }
         }
+        turnStarts.set(String(session.id), now)
+        return
+      }
+      if (event.type !== 'turn/end') return
+      const prefixes = cfg.excludeSessionPrefixes || ['msgw-']
+      if (isExcludedSession(session.id, prefixes)) return
+      const reason = event.data?.reason
+      const kind = reason?.kind === 'completed' ? 'task_done' : 'error'
+      const events = new Set(cfg.events?.length ? cfg.events : ['task_done', 'error'])
+      if (!events.has(kind)) return
+      const gw = getGw()
+      if (!gw) return
+      const started = turnStarts.get(String(session.id))
+      turnStarts.delete(String(session.id))
+      const dur = started ? Math.round((Date.now() - started) / 1000) : null
+      const title = kind === 'task_done' ? 'Task completed' : 'Agent error'
+      const lines = [
+        `【${title}】`,
+        `session: ${session.id}`,
+      ]
+      if (dur != null) lines.push(`duration: ${dur}s`)
+      if (reason?.kind === 'error') {
+        lines.push(`error: ${reason.error?.message || reason.error?.code || 'unknown'}`)
       }
-      turnStarts.set(String(session.id), now)
-      return
+      const homeName = cfg.home || 'default'
+      const home = gw.messenger.home?.() || null
+      if (home && gw.isMuted?.(home.chatId)) return
+      gw.messengerSend({ platform: 'telegram', home: homeName }, { text: lines.join('\n') })
+        .catch((e) => ctx.logger?.warn?.(`notify bridge: ${e.message}`))
     }
-    if (event.type !== 'turn/end') return
-    const prefixes = cfg.excludeSessionPrefixes || ['msgw-']
-    if (isExcludedSession(session.id, prefixes)) return
-    const reason = event.data?.reason
-    const kind = reason?.kind === 'completed' ? 'task_done' : 'error'
-    const events = new Set(cfg.events?.length ? cfg.events : ['task_done', 'error'])
-    if (!events.has(kind)) return
-    const gw = getGw()
-    if (!gw) return
-    const started = turnStarts.get(String(session.id))
-    turnStarts.delete(String(session.id))
-    const dur = started ? Math.round((Date.now() - started) / 1000) : null
-    const title = kind === 'task_done' ? 'Task completed' : 'Agent error'
-    const lines = [
-      `【${title}】`,
-      `session: ${session.id}`,
-    ]
-    if (dur != null) lines.push(`duration: ${dur}s`)
-    if (reason?.kind === 'error') {
-      lines.push(`error: ${reason.error?.message || reason.error?.code || 'unknown'}`)
+
+    const un1 = ctx.on('session/event', handleNotify)
+    const un2 = ctx.on('turn/end', (session, data) => handleNotify(session, { type: 'turn/end', data }))
+    const un3 = ctx.on('turn/start', (session, data) => handleNotify(session, { type: 'turn/start', data }))
+    return () => {
+      if (typeof un1 === 'function') un1()
+      if (typeof un2 === 'function') un2()
+      if (typeof un3 === 'function') un3()
     }
-    const homeName = cfg.home || 'default'
-    const home = gw.messenger.home?.() || null
-    if (home && gw.isMuted?.(home.chatId)) return
-    gw.messengerSend({ platform: 'telegram', home: homeName }, { text: lines.join('\n') })
-      .catch((e) => ctx.logger?.warn?.(`notify bridge: ${e.message}`))
-  }), 'dsh-messenger-gateway: notify bridge')
+  }, 'dsh-messenger-gateway: notify bridge')
 
   ctx.effect(() => getWebServer().register({
     kind: 'exact', path: '/dsh-messenger-gateway/status',
@@ -538,39 +606,12 @@ export function apply(ctx, config) {
     },
   }), 'dsh-messenger-gateway: pairing reject')
 
-  const webhookPath = () => {
-    const p = String(source().telegram?.webhookPath || '').trim()
-    return p || '/dsh-messenger-gateway/telegram/webhook'
-  }
-
-  ctx.effect(() => getWebServer().register({
-    kind: 'exact', path: webhookPath(),
-    handler: async (req, res) => {
-      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
-      const cfg = source().telegram || {}
-      if (cfg.transport !== 'webhook') return writeJson(res, 404, { ok: false, error: 'webhook transport disabled' })
-      const secret = String(cfg.webhookSecret || '').trim()
-      if (!secret) {
-        return writeJson(res, 403, { ok: false, error: 'webhook secret not configured' })
-      }
-      const hdr = String(req.headers['x-telegram-bot-api-secret-token'] || '')
-      if (!timingSafeCompare(hdr, secret)) {
-        return writeJson(res, 403, { ok: false, error: 'bad secret' })
-      }
-      const gw = getGw()
-      const adapter = gw?.getAdapter?.('telegram')
-      if (!adapter?.handleWebhookUpdate) return writeJson(res, 503, { ok: false, error: 'telegram adapter unavailable' })
-      const parsed = await readJsonSafe(req, res, 2_097_152)
-      if (!parsed.ok) return
-      const update = parsed.data
-      try {
-        await adapter.handleWebhookUpdate(update)
-        writeJson(res, 200, { ok: true })
-      } catch (err) {
-        writeJson(res, 500, { ok: false, error: err.message })
-      }
-    },
-  }), 'dsh-messenger-gateway: telegram webhook')
+  ctx.effect(() => () => {
+    if (typeof webhookRouteDispose === 'function') {
+      try { webhookRouteDispose() } catch (e) { /* ignore */ }
+      webhookRouteDispose = null
+    }
+  }, 'dsh-messenger-gateway: telegram webhook')
 
   registerMessengerRoute(ctx, getGw, '/dsh-messenger-gateway/messenger/send', 'send', source)
   registerMessengerRoute(ctx, getGw, '/dsh-messenger-gateway/messenger/progress', 'progress', source)
@@ -583,6 +624,9 @@ export function apply(ctx, config) {
     endpoint: '/dsh-messenger-gateway/update',
   }), 'dsh-messenger-gateway: plugin updater')
 
-  ctx.on('dispose', () => { if (gateway) gateway.stop() })
+  ctx.on('dispose', () => {
+    if (gateway) gateway.stop()
+    if (typeof webhookRouteDispose === 'function') webhookRouteDispose()
+  })
   sync()
 }

package/lib/messenger-api.js

@@ -110,7 +110,29 @@ export function normalizeFiles(files) {
       err.status = 400
       throw err
     }
-    if (file.bytes) return file
+    if (file.bytes !== undefined) {
+      let buf = null
+      if (Buffer.isBuffer(file.bytes) || file.bytes instanceof Uint8Array) {
+        buf = Buffer.from(file.bytes)
+      } else if (Array.isArray(file.bytes)) {
+        buf = Buffer.from(file.bytes)
+      } else if (file.bytes && typeof file.bytes === 'object' && file.bytes.type === 'Buffer' && Array.isArray(file.bytes.data)) {
+        buf = Buffer.from(file.bytes.data)
+      } else if (typeof file.bytes === 'string') {
+        buf = Buffer.from(file.bytes, 'utf8')
+      }
+      if (!buf) {
+        const err = new Error(`files[${i}].bytes must be a Buffer, Uint8Array, or array of bytes`)
+        err.status = 400
+        throw err
+      }
+      return {
+        bytes: buf,
+        mime: file.mime || 'application/octet-stream',
+        kind: file.kind || 'document',
+        name: file.name || 'file',
+      }
+    }
     if (typeof file.dataBase64 === 'string') {
       return {
         bytes: Buffer.from(file.dataBase64, 'base64'),

package/lib/outbound.js

@@ -72,12 +72,54 @@ export async function readAttachmentBytes(ctx, ref) {
   }
 }
 
-export async function fetchInternalImage(baseUrl, path, signal) {
+export async function fetchInternalImage(baseUrl, path, signal, opts = {}) {
+  const { timeoutMs = 15_000, maxBytes = 20 * 1024 * 1024 } = opts
+  const timeoutSignal = AbortSignal.timeout(timeoutMs)
+  const effectiveSignal = signal
+    ? (typeof AbortSignal.any === 'function' ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal)
+    : timeoutSignal
+
   const url = new URL(path, baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`)
-  const res = await fetch(url, { signal })
+  const res = await fetch(url, { signal: effectiveSignal })
   if (!res.ok) throw new Error(`image fetch HTTP ${res.status}`)
-  const bytes = new Uint8Array(await res.arrayBuffer())
-  const mime = res.headers.get('content-type') || 'image/png'
+
+  const clHeader = res.headers?.get?.('content-length')
+  const cl = Number(clHeader)
+  if (Number.isFinite(cl) && cl > maxBytes) {
+    throw new Error(`image size (${cl} bytes) exceeds limit of ${maxBytes} bytes`)
+  }
+
+  let bytes
+  if (res.body && typeof res.body.getReader === 'function') {
+    const reader = res.body.getReader()
+    const chunks = []
+    let total = 0
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      total += value.length
+      if (total > maxBytes) {
+        reader.cancel().catch(() => {})
+        throw new Error(`image size exceeds limit of ${maxBytes} bytes`)
+      }
+      chunks.push(value)
+    }
+    const combined = new Uint8Array(total)
+    let offset = 0
+    for (const chunk of chunks) {
+      combined.set(chunk, offset)
+      offset += chunk.length
+    }
+    bytes = combined
+  } else {
+    const ab = await res.arrayBuffer()
+    if (ab.byteLength > maxBytes) {
+      throw new Error(`image size exceeds limit of ${maxBytes} bytes`)
+    }
+    bytes = new Uint8Array(ab)
+  }
+
+  const mime = res.headers?.get?.('content-type') || 'image/png'
   const fromQuery = url.searchParams.get('id') || url.searchParams.get('name')
   const name = fromQuery ? `image-${fromQuery.slice(0, 32)}.png` : 'image.png'
   return { bytes, mime, kind: 'photo', name }
@@ -87,7 +129,7 @@ const DEFAULT_MAX_OUTBOUND_FILES = 10
 
 /** Build Telegram-ready files from assistant image blocks and inline plugin URLs. */
 export async function buildOutboundFiles(ctx, baseUrl, collector, opts = {}) {
-  const { signal, logger, maxFiles = DEFAULT_MAX_OUTBOUND_FILES } = opts
+  const { signal, logger, maxFiles = DEFAULT_MAX_OUTBOUND_FILES, maxImageBytes, imageTimeoutMs } = opts
   const files = []
   const refs = dedupeAttachmentRefs(collector.images)
   for (const ref of refs) {
@@ -104,7 +146,10 @@ export async function buildOutboundFiles(ctx, baseUrl, collector, opts = {}) {
     if (files.length >= maxFiles) break
     if (signal?.aborted) break
     try {
-      files.push(await fetchInternalImage(baseUrl, path, signal))
+      files.push(await fetchInternalImage(baseUrl, path, signal, {
+        maxBytes: maxImageBytes,
+        timeoutMs: imageTimeoutMs,
+      }))
     } catch (e) {
       logger?.warn?.(`outbound url image: ${e.message}`)
     }

package/lib/personas.js

@@ -1,5 +1,5 @@
-import { readFileSync, writeFileSync, mkdirSync } from 'node:fs'
-import { dirname } from 'node:path'
+import { readFileSync } from 'node:fs'
+import { writeJsonAtomicSync } from './storage-atomic.js'
 
 export const BUILTIN_PERSONAS = {
   default: {
@@ -87,8 +87,7 @@ export function createPersonaStore(filePath, { logger } = {}) {
 
   function save() {
     try {
-      mkdirSync(dirname(filePath), { recursive: true })
-      writeFileSync(filePath, JSON.stringify(cache, null, 2), 'utf8')
+      writeJsonAtomicSync(filePath, cache)
     } catch (err) {
       logger?.warn?.('[dsh-messenger-gateway] personas save error:', err?.message || err)
     }

package/lib/scheduler.js

@@ -42,10 +42,16 @@ export function createScheduler(filePath, onDue, options = {}) {
   async function load() {
     try {
       const raw = await readFile(filePath, 'utf8')
-      tasks = JSON.parse(raw)
+      const parsed = JSON.parse(raw)
+      if (Array.isArray(parsed)) {
+        tasks = parsed
+      } else {
+        logger?.warn?.(`[dsh-messenger-gateway] scheduler invalid tasks payload in ${filePath}: expected array, got ${typeof parsed}; resetting to empty list`)
+        tasks = []
+      }
     } catch (err) {
       if (err?.code !== 'ENOENT') {
-        logger?.debug?.('[dsh-messenger-gateway] scheduler load error:', err?.message || err)
+        logger?.warn?.('[dsh-messenger-gateway] scheduler load error:', err?.message || err)
       }
       tasks = []
     }
@@ -56,6 +62,7 @@ export function createScheduler(filePath, onDue, options = {}) {
 
   async function save() {
     if (!filePath) return
+    if (!Array.isArray(tasks)) tasks = []
     try {
       const now = Date.now()
       tasks = tasks.filter((t) => {
@@ -71,6 +78,7 @@ export function createScheduler(filePath, onDue, options = {}) {
 
   async function checkDue() {
     if (!loaded) await load()
+    if (!Array.isArray(tasks)) tasks = []
     const now = Date.now()
     const due = tasks.filter((t) => t.status === 'pending' && t.dueAt <= now)
 
@@ -99,10 +107,10 @@ export function createScheduler(filePath, onDue, options = {}) {
   function start(intervalMs = 5000) {
     if (timer) clearInterval(timer)
     timer = setInterval(() => {
-      checkDue().catch((err) => { logger?.debug?.('[dsh-messenger-gateway] scheduler checkDue error:', err?.message || err) })
+      checkDue().catch((err) => { logger?.warn?.('[dsh-messenger-gateway] scheduler checkDue error:', err?.message || err) })
     }, intervalMs)
     timer.unref?.()
-    checkDue().catch((err) => { logger?.debug?.('[dsh-messenger-gateway] scheduler checkDue error:', err?.message || err) })
+    checkDue().catch((err) => { logger?.warn?.('[dsh-messenger-gateway] scheduler checkDue error:', err?.message || err) })
   }
 
   function stop() {

package/lib/settings-bridge.js

@@ -78,7 +78,7 @@ export function setupSettings(ctx, { namespace, Config, resolveConfig, baseConfi
     source = () => currentConfig
 
     const persist = async (next) => {
-      const payload = Config(next)
+      const payload = resolveConfig(next)
       if (typeof service.replace === 'function') {
         await service.replace(namespace, payload, getRevision())
       } else if (typeof service.update === 'function') {
@@ -88,7 +88,7 @@ export function setupSettings(ctx, { namespace, Config, resolveConfig, baseConfi
       } else {
         throw new Error('settings service cannot persist configuration')
       }
-      currentConfig = resolveConfig(payload)
+      currentConfig = payload
       sync()
       for (const cb of watchers) {
         try { cb(currentConfig) } catch (err) { logger?.debug?.(`${namespace}: watcher error:`, err?.message || err) }

package/lib/storage-atomic.js

@@ -1,4 +1,5 @@
 import { writeFile, rename, mkdir, unlink } from 'node:fs/promises'
+import { writeFileSync, renameSync, mkdirSync, unlinkSync } from 'node:fs'
 import { dirname } from 'node:path'
 import { randomUUID } from 'node:crypto'
 
@@ -18,4 +19,20 @@ export async function writeJsonAtomic(filePath, data) {
     await unlink(tmpPath).catch(() => {})
     throw err
   }
+}
+
+/**
+ * Synchronous atomic JSON write via temporary file and rename.
+ */
+export function writeJsonAtomicSync(filePath, data) {
+  const dir = dirname(filePath)
+  mkdirSync(dir, { recursive: true })
+  const tmpPath = `${filePath}.${randomUUID().slice(0, 8)}.tmp`
+  try {
+    writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf8')
+    renameSync(tmpPath, filePath)
+  } catch (err) {
+    try { unlinkSync(tmpPath) } catch { /* ignore */ }
+    throw err
+  }
 }

package/lib/stream.js

@@ -1,8 +1,12 @@
 /** Helpers for Telegram streaming edits + progress. */
 
 export function extractTextDelta(chunk) {
+  if (typeof chunk === 'string') return chunk
   if (!chunk || typeof chunk !== 'object') return ''
   if (chunk.type === 'text-delta' && typeof chunk.text === 'string') return chunk.text
+  if (chunk.type === 'text' && typeof chunk.text === 'string') return chunk.text
+  if (!chunk.type && typeof chunk.text === 'string') return chunk.text
+  if (!chunk.type && typeof chunk.delta === 'string') return chunk.delta
   return ''
 }
 

package/lib/updater.js

@@ -181,15 +181,20 @@ export async function getUpdateStatus(options, target = runtime()) {
   }
 }
 
+export function buildUpdateArgs(target, packageSpec, options = {}) {
+  return [
+    target.cliEntry, 'plugin', '--profile', target.profileName, 'add',
+    packageSpec,
+    `--registry=${options.registry ?? 'https://registry.npmjs.org/'}`,
+  ]
+}
+
 export async function installExact(target, packageSpec, options = {}) {
   if (target.cliEntry === undefined) throw new Error('Automatic update CLI entry is unavailable in this runtime.')
   return new Promise((resolvePromise, reject) => {
-    const args = [
-      target.cliEntry, 'plugin', '--profile', target.profileName, 'add',
-      '--config.minimumReleaseAge=0', packageSpec,
-      `--registry=${options.registry ?? 'https://registry.npmjs.org/'}`,
-    ]
-    const child = spawn(process.execPath, args, {
+    const args = buildUpdateArgs(target, packageSpec, options)
+    const spawnFn = options.spawn ?? spawn
+    const child = spawnFn(process.execPath, args, {
       cwd: target.profileDir,
       windowsHide: true,
       stdio: ['ignore', 'pipe', 'pipe'],

package/package.json

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