@goodandready/dsh-messenger-gateway 0.3.12 → 0.3.14

package/lib/client.js

@@ -1,6 +1,6 @@
 // dsh-messenger-gateway — browser (client) half.
 // Settings card on Plugins → Plugin settings tab (settings.plugin.item).
-// Fallback to sidebar settings.section when the slot is unavailable.
+// Config managed via reactive ctx.settingsScope snapshot.
 
 window.__ModuleLoader__.load({
   id: '@goodandready/dsh-messenger-gateway',
@@ -52,6 +52,7 @@ const css =
       description: 'Telegram bot: text, voice, photos and documents.',
       loading: 'Loading…',
       save: 'Save',
+      saved: 'Saved',
       saving: 'Saving…',
       showAdvanced: 'Advanced settings',
       hideAdvanced: 'Hide advanced',
@@ -125,6 +126,7 @@ const css =
       description: 'Telegram-бот: текст, голос, фото и документы.',
       loading: 'Загрузка…',
       save: 'Сохранить',
+      saved: 'Сохранено',
       saving: 'Сохранение…',
       showAdvanced: 'Расширенные настройки',
       hideAdvanced: 'Скрыть расширенные',
@@ -227,16 +229,104 @@ const css =
       )
     }
 
-    function MessengerSettingsForm({ t }) {
-      const [cfg, setCfg] = React.useState(null)
+    const SETTINGS_KEYS = ['enabled', 'telegram', 'agent', 'media', 'tts']
+
+    function draftFromStored(s) {
+      const src = (s && typeof s === 'object') ? s : {}
+      const t = src.telegram || {}
+      const a = src.agent || {}
+      const m = src.media || {}
+      const tts = src.tts || {}
+      return {
+        enabled: src.enabled !== false,
+        telegram: {
+          enabled: t.enabled === true,
+          allowedUserIds: Array.isArray(t.allowedUserIds) ? t.allowedUserIds : [],
+          pollTimeoutSeconds: Number(t.pollTimeoutSeconds) || 50,
+          pollIntervalMs: Number(t.pollIntervalMs) || 500,
+          commands: Array.isArray(t.commands) ? t.commands : [],
+          textFormat: t.textFormat === 'plain' ? 'plain' : 'html',
+          homeChatId: t.homeChatId != null ? t.homeChatId : '',
+          homeThreadId: Number(t.homeThreadId) || 0,
+          homes: Array.isArray(t.homes) ? t.homes : [],
+          pairingEnabled: t.pairingEnabled !== false,
+          streaming: t.streaming === true,
+          streamEditIntervalMs: Number(t.streamEditIntervalMs) || 1200,
+          progressEnabled: t.progressEnabled !== false,
+          approvalsEnabled: t.approvalsEnabled !== false,
+          groupsEnabled: t.groupsEnabled !== false,
+          groupRequireMention: t.groupRequireMention !== false,
+          reactionsEnabled: t.reactionsEnabled !== false,
+          statusIndicator: t.statusIndicator === true,
+          statusOnline: t.statusOnline || 'Online',
+          statusOffline: t.statusOffline || 'Offline',
+          transport: t.transport === 'webhook' ? 'webhook' : 'poll',
+          webhookUrl: t.webhookUrl || '',
+          webhookPath: t.webhookPath || '/dsh-messenger-gateway/telegram/webhook',
+          voiceMode: t.voiceMode || 'mirror',
+          quickActions: t.quickActions === true,
+          artifactPreviews: t.artifactPreviews !== false,
+          notifyBridge: t.notifyBridge || { enabled: false, events: ['task_done', 'error'], home: 'default', excludeSessionPrefixes: ['msgw-'] },
+          alerts: t.alerts || { enabled: false, chatId: '', threadId: 0, home: '', events: ['error', 'pairing'] },
+          botToken: t.botToken || '',
+          webhookSecret: t.webhookSecret || '',
+        },
+        agent: {
+          provider: a.provider || '',
+          model: a.model || '',
+          instructionPrefix: a.instructionPrefix || '',
+          maxMessageLength: Number(a.maxMessageLength) || 4000,
+          turnTimeoutMs: Number(a.turnTimeoutMs) || 600000,
+          idleTimeoutMs: Number(a.idleTimeoutMs) || 3600000,
+          photoOnlyMode: a.photoOnlyMode || 'prompt',
+          sessionScope: a.sessionScope || 'user',
+        },
+        media: {
+          maxDocBytes: Number(m.maxDocBytes) || 20971520,
+          maxImageBytes: Number(m.maxImageBytes) || 20971520,
+          maxTextInjectBytes: Number(m.maxTextInjectBytes) || 102400,
+        },
+        tts: {
+          enabled: tts.enabled === true,
+          maxChars: Number(tts.maxChars) || 4000,
+          voiceSummary: tts.voiceSummary === true,
+        },
+      }
+    }
+
+    function MessengerSettingsForm({ t, ctx }) {
       const [token, setToken] = React.useState('')
       const [webhookSecret, setWebhookSecret] = React.useState('')
       const [allowText, setAllowText] = React.useState('')
       const [pending, setPending] = React.useState([])
       const [err, setErr] = React.useState('')
+      const [msg, setMsg] = React.useState('')
       const [busy, setBusy] = React.useState(false)
       const [showAdvanced, setShowAdvanced] = React.useState(false)
 
+      const scope = React.useMemo(
+        () => (ctx && ctx.settingsScope ? ctx.settingsScope.bind({ namespace: NS }) : undefined),
+        [ctx],
+      )
+
+      const snapshot = React.useSyncExternalStore(
+        React.useMemo(() => (cb) => (scope ? scope.subscribe(cb) : () => {}), [scope]),
+        React.useCallback(() => (scope ? scope.getSnapshot() : { status: 'loading' }), [scope]),
+        React.useCallback(() => ({ status: 'loading' }), []),
+      )
+
+      const snapStatus = (snapshot && snapshot.status) || 'loading'
+      const stored = (snapshot && snapshot.value) || {}
+
+      const [cfg, setCfg] = React.useState(null)
+
+      React.useEffect(() => {
+        if (snapStatus === 'ready' && cfg === null) {
+          setCfg(draftFromStored(stored))
+          setAllowText(idsToText(stored?.telegram?.allowedUserIds))
+        }
+      }, [snapStatus, stored, cfg])
+
       const loadPairing = React.useCallback(async () => {
         try {
           const res = await fetch('/dsh-messenger-gateway/pairing', { credentials: 'same-origin' })
@@ -245,16 +335,9 @@ const css =
         } catch {}
       }, [])
 
-      const load = React.useCallback(async () => {
-        const res = await fetch('/dsh-messenger-gateway/config', { credentials: 'same-origin' })
-        const data = await res.json()
-        if (!res.ok || !data.ok) throw new Error(data.error || res.status)
-        setCfg(data.config)
-        setAllowText(idsToText(data.config?.telegram?.allowedUserIds))
-        await loadPairing()
-      }, [loadPairing])
-
-      React.useEffect(() => { load().catch((e) => setErr(String(e.message || e))) }, [load])
+      React.useEffect(() => {
+        if (snapStatus === 'ready') loadPairing()
+      }, [snapStatus, loadPairing])
 
       const mergePatch = (base, patch) => ({
         ...base,
@@ -266,26 +349,47 @@ const css =
       })
 
       const save = async (patch = {}) => {
-        setBusy(true); setErr('')
+        if (!scope || !cfg) return
+        setBusy(true); setErr(''); setMsg('')
         try {
           let next = mergePatch(cfg, patch)
           if (token.trim()) next.telegram = { ...next.telegram, botToken: token.trim() }
           if (webhookSecret.trim()) next.telegram = { ...next.telegram, webhookSecret: webhookSecret.trim() }
           next.telegram.allowedUserIds = textToIds(allowText)
-          const res = await fetch('/dsh-messenger-gateway/config', {
-            method: 'PUT', credentials: 'same-origin',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ config: next }),
-          })
-          const data = await res.json()
-          if (!res.ok || !data.ok) throw new Error(data.error || res.status)
-          setCfg(data.config); setToken(''); setWebhookSecret('')
-          setAllowText(idsToText(data.config?.telegram?.allowedUserIds))
+
+          const broken = []
+          for (const key of SETTINGS_KEYS) {
+            if (next[key] !== undefined) {
+              try {
+                await scope.set(key, next[key])
+              } catch (e) {
+                broken.push(key + ': ' + (e && e.message || String(e)))
+              }
+            }
+          }
+          if (broken.length) {
+            setErr('Save failed — ' + broken.join('; '))
+            return
+          }
+          setCfg(next)
+          setToken('')
+          setWebhookSecret('')
+          setMsg(t('saved'))
+          setTimeout(() => setMsg(''), 3000)
           await loadPairing()
         } catch (e) { setErr(String(e.message || e)) } finally { setBusy(false) }
       }
 
-      if (!cfg) return React.createElement('div', null, err || t('loading'))
+      if (snapStatus === 'loading') {
+        return React.createElement('div', { className: 'msgw-sub', style: { padding: '12px 0' } }, t('loading'))
+      }
+      if (snapStatus !== 'ready') {
+        return React.createElement('div', { className: 'msgw-err', style: { padding: '12px 0' } },
+          'Settings unavailable (snapshot status: ' + snapStatus + '). Host namespace may be missing.')
+      }
+      if (!cfg) {
+        return React.createElement('div', { className: 'msgw-sub', style: { padding: '12px 0' } }, t('loading'))
+      }
 
       return React.createElement('div', { className: 'msgw-form' },
         React.createElement('div', null,
@@ -475,6 +579,7 @@ const css =
         ) : null,
 
         err ? React.createElement('div', { className: 'msgw-err' }, err) : null,
+        msg ? React.createElement('div', { style: { color: 'var(--dsw-alias-state-success-primary, #10b981)', fontSize: '13px', padding: '8px 0' } }, msg) : null,
         React.createElement('div', { className: 'msgw-foot' },
           React.createElement('button', { type: 'button', className: 'msgw-save', disabled: busy, onClick: () => save({}) }, busy ? t('saving') : t('save')),
         ),
@@ -498,7 +603,7 @@ const css =
           React.createElement('span', { className: 'msgw-chev' }, open ? '\u25B2' : '\u25BC'),
         ),
         open ? React.createElement('div', { className: 'msgw-body' },
-          React.createElement(MessengerSettingsForm, { t }),
+          React.createElement(MessengerSettingsForm, { t, ctx: props.ctx }),
         ) : null,
       )
     }
@@ -507,36 +612,18 @@ const css =
       ctx.effect(() => ctx.locale.register(NS, { en, ru }), 'dsh-messenger-gateway: dictionaries')
       function useLocale() { return useActiveLocale(ctx) }
 
-      const tryPluginItem = () => {
-        try {
-          ctx.slots.inject('settings.plugin.item', () =>
-            ctx.slots.register({
-              name: 'settings.plugin.item',
-              key: NS,
-              locale: NS,
-              inject: () => ({ ctx }),
-            }, (props) => React.createElement(PluginCard, { ...props, locale: useLocale() })),
-          )
-          return true
-        } catch {
-          return false
-        }
-      }
-
-      if (!tryPluginItem()) {
-        ctx.slots.inject('settings.section', () => ctx.slots.register({
-          name: 'settings.section',
-          id: NS,
-          order: 36,
-          label: () => makeT(useActiveLocale(ctx))('title'),
-        }, (props) => React.createElement('div', { style: { padding: 16 } },
-          React.createElement(MessengerSettingsForm, { t: makeT(useActiveLocale(ctx)) }),
-        )))
-      }
+      ctx.slots.inject('settings.plugin.item', () =>
+        ctx.slots.register({
+          name: 'settings.plugin.item',
+          key: NS,
+          locale: NS,
+          inject: () => ({ ctx }),
+        }, (props) => React.createElement(PluginCard, { ...props, ctx, locale: useLocale() })),
+      )
     }
 
     exports.apply = apply
-    exports.inject = ['slots', 'locale']
+    exports.inject = ['slots', 'locale', 'settingsScope']
     return module.exports
   },
 })

package/lib/gateway.js

@@ -174,11 +174,10 @@ export class Gateway {
         this.ctx.logger?.warn?.(`dsh-messenger-gateway: ${adapter.name}: ${err.message}`)
       }
     }
-    const idleMs = Number(this.config.agent?.idleTimeoutMs) || 0
-    if (idleMs > 0) {
-      this.idleTimer = setInterval(() => this.reapIdle(), Math.min(idleMs, 60_000))
-      this.idleTimer.unref?.()
-    }
+    const rawIdle = Number(this.config.agent?.idleTimeoutMs)
+    const idleMs = Number.isFinite(rawIdle) && rawIdle > 0 ? rawIdle : 86_400_000
+    this.idleTimer = setInterval(() => this.reapIdle(), Math.min(idleMs, 60_000))
+    this.idleTimer.unref?.()
     this.scheduler.start()
   }
 
@@ -565,30 +564,37 @@ export class Gateway {
     if (cmd === '/start') return reply('Шлюз подключён. Пишите сообщение агенту. /help — команды.', { replyMarkup: REMOVE_REPLY_KEYBOARD })
     if (cmd === '/help') {
       return reply([
-        'Команды:',
-        '/help — справка',
-        '/new — новая сессия',
-        '/whoami — ваш id',
-        '/stop — прервать текущий ответ',
-        '/status — статус шлюза',
-        '/model — текущая модель; /model provider model — сменить',
-        '/role [name] — персоны и роли агента (/role list)',
-        '/skills / /tools — список инструментов и навыков',
-        '/fork — ответвление текущей сессии',
-        '/export — выгрузка истории диалога в Markdown',
-        '/rewind [N] — откат последних N сообщений',
-        '/files [dir] — менеджер файлов в рабочей папке агента',
-        '/get <path> — скачать файл из рабочей папки в Telegram',
-        '/pair CODE — одобрить пользователя',
-        '/sethome [name] — этот чат = home (имя опционально)',
-        '/home — список home',
-        '/setalert — назначить этот чат каналом алертов',
-        '/alert [test] — статус канала алертов и тест',
-        '/remind <время> <текст> — напоминание (/remind 10m текст, /remind list)',
-        '/voice on|off|status — голосовые ответы',
-        '/tts on|off|status — озвучка в этом чате',
-        '/mute / /unmute — заглушить уведомления в этот чат',
-        '/keyboard on|off — быстрая клавиатура',
+        '📖 <b>Команды бота:</b>',
+        '',
+        '💬 <b>Диалог:</b>',
+        '• /help — эта справка',
+        '• /new — новая сессия',
+        '• /stop — прервать текущий ответ',
+        '• /model — интерактивный выбор модели (/model list)',
+        '• /role [name] — персоны и роли агента (/role list)',
+        '• /rewind [N] — откат последних N ходов',
+        '• /fork — форк сессии в новую ветку',
+        '• /export — выгрузка истории в Markdown',
+        '',
+        '🛠️ <b>Инструменты и файлы:</b>',
+        '• /skills / /tools — список активных инструментов',
+        '• /files [dir] — проводник рабочей папки',
+        '• /get <path> — скачать файл в Telegram',
+        '• /remind <время> <текст> — напоминание (/remind 10m текст)',
+        '',
+        '⚙️ <b>Настройки:</b>',
+        '• /status — статус шлюза и модели',
+        '• /top — системные ресурсы (RAM, uptime)',
+        '• /keyboard on|off — быстрые кнопки',
+        '• /voice on|off|status — голосовые ответы',
+        '• /tts on|off|status — озвучка в этом чате',
+        '• /mute / /unmute — заглушить уведомления в этот чат',
+        '',
+        '🔒 <b>Доступ и каналы:</b>',
+        '• /whoami — ваш Telegram id',
+        '• /pair CODE — одобрить код сопряжения',
+        '• /sethome [name] — привязать домашний чат',
+        '• /setalert — назначить канал алертов',
       ].join('\n'))
     }
     if (cmd === '/role' || cmd === '/persona') {
@@ -1318,8 +1324,8 @@ export class Gateway {
   }
 
   reapIdle() {
-    const timeout = Number(this.config.agent?.idleTimeoutMs) || 0
-    if (timeout <= 0) return
+    const rawTimeout = Number(this.config.agent?.idleTimeoutMs)
+    const timeout = Number.isFinite(rawTimeout) && rawTimeout > 0 ? rawTimeout : 86_400_000
     const now = Date.now()
     for (const [key, chat] of this.chats) {
       if (!chat.turnActive && now - chat.lastUsed > timeout) {

package/lib/pairing.js

@@ -1,5 +1,5 @@
-import { randomBytes } from 'node:crypto'
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { randomBytes, randomUUID } from 'node:crypto'
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, unlinkSync } from 'node:fs'
 import { dirname } from 'node:path'
 
 const ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'
@@ -11,6 +11,19 @@ export function generatePairingCode(length = 8) {
   return out
 }
 
+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 {}
+    throw err
+  }
+}
+
 export function createPairingStore(filePath) {
   const state = { pending: {}, /** @type {number[]} */ approved: [] }
   if (filePath && existsSync(filePath)) {
@@ -22,8 +35,9 @@ export function createPairingStore(filePath) {
   }
   const persist = () => {
     if (!filePath) return
-    mkdirSync(dirname(filePath), { recursive: true })
-    writeFileSync(filePath, JSON.stringify({ approved: state.approved, pending: state.pending }, null, 2))
+    try {
+      writeJsonAtomicSync(filePath, { approved: state.approved, pending: state.pending })
+    } catch {}
   }
   const prune = () => {
     const now = Date.now()
@@ -107,4 +121,4 @@ export function createPairingStore(filePath) {
       return { ok: true, userId: row.userId, username: row.username }
     },
   }
-}
+}

package/lib/scheduler.js

@@ -1,6 +1,6 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises'
-import { dirname } from 'node:path'
+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
@@ -49,6 +49,7 @@ export function createScheduler(filePath, onDue) {
   const RETENTION_MS = 7 * 86400 * 1000
 
   async function save() {
+    if (!filePath) return
     try {
       const now = Date.now()
       tasks = tasks.filter((t) => {
@@ -56,8 +57,7 @@ export function createScheduler(filePath, onDue) {
         const finishTime = t.firedAt || t.createdAt || 0
         return (now - finishTime) < RETENTION_MS
       })
-      await mkdir(dirname(filePath), { recursive: true })
-      await writeFile(filePath, JSON.stringify(tasks, null, 2), 'utf8')
+      await writeJsonAtomic(filePath, tasks)
     } catch {}
   }
 
@@ -140,4 +140,4 @@ export function createScheduler(filePath, onDue) {
     checkDue,
     getTasks: () => tasks,
   }
-}
+}

package/lib/storage-atomic.js

@@ -0,0 +1,21 @@
+import { writeFile, rename, mkdir, unlink } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import { randomUUID } from 'node:crypto'
+
+/**
+ * Write JSON atomically via temporary file and rename.
+ * Guarantees that readers never observe partially written files.
+ */
+export async function writeJsonAtomic(filePath, data) {
+  const dir = dirname(filePath)
+  await mkdir(dir, { recursive: true })
+  const tmpPath = `${filePath}.${randomUUID().slice(0, 8)}.tmp`
+  const serialized = JSON.stringify(data, null, 2)
+  try {
+    await writeFile(tmpPath, serialized, 'utf8')
+    await rename(tmpPath, filePath)
+  } catch (err) {
+    await unlink(tmpPath).catch(() => {})
+    throw err
+  }
+}

package/lib/stream.js

@@ -24,22 +24,48 @@ export function buildStreamPreview(streamText, toolName, maxLen = 3500) {
   return combined.slice(0, maxLen - 1) + '…'
 }
 
+export function parseRetryAfter(err) {
+  if (!err) return 0
+  const msg = err.message || String(err)
+  const match = /retry after (\d+)/i.exec(msg)
+  if (match) return parseInt(match[1], 10) * 1000
+  return 0
+}
+
 export function createEditScheduler(editFn, intervalMs = 1200) {
   let pending = null
   let timer = null
   let lastSent = ''
   let inFlight = Promise.resolve()
+  let retryDelayMs = 0
+
   const flush = () => {
     timer = null
     if (pending === null || pending === lastSent) return
     const text = pending
     inFlight = inFlight.then(async () => {
       try {
+        if (retryDelayMs > 0) {
+          const delay = retryDelayMs
+          retryDelayMs = 0
+          await new Promise((r) => setTimeout(r, delay))
+        }
         await editFn(text)
         lastSent = text
-      } catch {}
+      } catch (err) {
+        const retry = parseRetryAfter(err)
+        if (retry > 0) {
+          retryDelayMs = retry
+          // Re-schedule flush with retry delay
+          if (!timer) {
+            timer = setTimeout(flush, retry + 100)
+            timer.unref?.()
+          }
+        }
+      }
     })
   }
+
   return {
     push(text) {
       pending = text
@@ -51,6 +77,17 @@ export function createEditScheduler(editFn, intervalMs = 1200) {
       if (timer) { clearTimeout(timer); timer = null }
       flush()
       await inFlight
+      // If there's still a pending difference (e.g. rate limit delay happened), wait and retry
+      if (pending !== null && pending !== lastSent) {
+        if (retryDelayMs > 0) {
+          await new Promise((r) => setTimeout(r, retryDelayMs + 50))
+          retryDelayMs = 0
+        }
+        try {
+          await editFn(pending)
+          lastSent = pending
+        } catch {}
+      }
     },
   }
 }
@@ -61,4 +98,4 @@ export function startTypingHeartbeat(typingFn, intervalMs = 4000) {
   const timer = setInterval(() => { typingFn().catch?.(() => {}) }, intervalMs)
   timer.unref?.()
   return () => clearInterval(timer)
-}
+}

package/lib/voice-prefs.js

@@ -1,5 +1,19 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs"
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, unlinkSync } from "node:fs"
 import { dirname } from "node:path"
+import { randomUUID } from "node:crypto"
+
+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 {}
+    throw err
+  }
+}
 
 export function createVoicePrefs(filePath) {
   /** @type {Record<string, boolean>} */
@@ -12,8 +26,9 @@ export function createVoicePrefs(filePath) {
   }
   const persist = () => {
     if (!filePath) return
-    mkdirSync(dirname(filePath), { recursive: true })
-    writeFileSync(filePath, JSON.stringify(state, null, 2))
+    try {
+      writeJsonAtomicSync(filePath, state)
+    } catch {}
   }
   const key = (userId) => String(Number(userId) || userId || "")
   return {
@@ -43,4 +58,4 @@ export function shouldSpeakReply({ globalTts, voiceMode, inboundWasVoice, userPr
   if (voiceMode === "off") return false
   // mirror: speak if inbound was voice
   return Boolean(inboundWasVoice)
-}
+}

package/package.json

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