@goodandready/dsh-messenger-gateway 0.3.2 → 0.3.9

package/lib/index.js

@@ -52,6 +52,8 @@ function publicConfig(cfg) {
       webhookSecretConfigured: Boolean(String(cfg.telegram.webhookSecret || '').trim()),
       botTokenConfigured: Boolean(String(cfg.telegram.botToken || '').trim()),
       voiceMode: cfg.telegram.voiceMode,
+      quickActions: cfg.telegram.quickActions !== false,
+      artifactPreviews: cfg.telegram.artifactPreviews !== false,
       notifyBridge: {
         enabled: Boolean(cfg.telegram.notifyBridge?.enabled),
         events: cfg.telegram.notifyBridge?.events || ['task_done', 'error'],
@@ -167,15 +169,27 @@ export function apply(ctx, config) {
     ctx.effect(() => ctx.tools.register(defineTool({
       name: 'messenger_ask',
       description:
-        'Ask the Telegram user a multiple-choice question with inline buttons and wait for their choice. '
-        + 'Use for confirmations and short choices. Only works inside messenger-gateway sessions (msgw-*).',
+        'Ask the Telegram user a single or multiple-choice question with inline buttons/checkboxes and wait for their choice. '
+        + 'Supports mode: "single" (default) or "multi" (checkboxes with Done/Cancel buttons). Only works inside messenger-gateway sessions (msgw-*).',
       parameters: {
         text: { type: 'string', required: true, description: 'Question text shown in Telegram.' },
         buttons: {
           type: 'array',
-          required: true,
-          description: 'Rows of buttons: [[{ id, text }, ...], ...]',
+          description: 'Rows of buttons: [[{ id, text }, ...], ...] (for single choice)',
         },
+        options: {
+          type: 'array',
+          description: 'List of options: [{ id, text, selected?: boolean }, ...] (for single or multi choice)',
+        },
+        mode: {
+          type: 'string',
+          description: '"single" for instant choice or "multi" for checkboxes form',
+        },
+        selected: {
+          type: 'array',
+          description: 'Initial selected option IDs for multi-select mode',
+        },
+        pageSize: { type: 'number', description: 'Number of options per page (default 6).' },
         timeoutMs: { type: 'number', description: 'Wait timeout ms (default 300000).' },
       },
       output: {
@@ -185,6 +199,7 @@ export function apply(ctx, config) {
           properties: {
             ok: { type: 'boolean' },
             buttonId: { type: 'string' },
+            selected: { type: 'array', items: { type: 'string' } },
             data: { type: 'string' },
             error: { type: 'string' },
           },
@@ -192,7 +207,7 @@ export function apply(ctx, config) {
         render: (_args, value) => [{
           type: 'text',
           text: value && value.ok
-            ? `User chose: ${value.buttonId}`
+            ? (value.selected?.length ? `User selected: ${value.selected.join(', ')}` : `User chose: ${value.buttonId}`)
             : `messenger_ask failed: ${value && value.error ? value.error : 'unknown'}`,
         }],
       },
@@ -200,12 +215,15 @@ export function apply(ctx, config) {
         const gw = getGw()
         if (!gw) return { ok: false, error: 'gateway not running' }
         try {
-          const buttons = args.buttons
           const result = await gw.messengerAskFromAgent(exec.agent, {
             text: String(args.text || ''),
-            buttons,
+            buttons: args.buttons,
+            options: args.options,
+            mode: args.mode,
+            selected: args.selected,
+            pageSize: args.pageSize,
           }, Number(args.timeoutMs) || 300_000)
-          return { ok: true, buttonId: result?.buttonId, data: result?.data }
+          return { ok: true, buttonId: result?.buttonId, selected: result?.selected, data: result?.data }
         } catch (err) {
           return { ok: false, error: err instanceof Error ? err.message : String(err) }
         }
@@ -277,6 +295,45 @@ export function apply(ctx, config) {
     },
   }), 'dsh-messenger-gateway: messenger schema')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact', path: '/dsh-messenger-gateway/events',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
+      const gw = getGw()
+      if (!gw) return writeJson(res, 503, { ok: false, error: 'gateway not ready' })
+      let payload
+      try {
+        payload = JSON.parse((await readBody(req)).toString('utf8') || '{}')
+      } catch {
+        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' })
+        }
+      }
+
+      const { target, text, home, chatId, threadId, platform = 'telegram', files } = payload
+      if (!text && (!files || !files.length)) {
+        return writeJson(res, 400, { ok: false, error: 'text or files required' })
+      }
+
+      const dest = target || { platform, chatId, threadId, home }
+      try {
+        const result = await gw.messengerSend(dest, { text, files })
+        writeJson(res, 200, { ok: true, sent: result })
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: err.message })
+      }
+    },
+  }), 'dsh-messenger-gateway: webhook events')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact', path: '/dsh-messenger-gateway/config',
     handler: async (req, res) => {

package/lib/messenger-api.js

@@ -147,13 +147,31 @@ export function normalizeAskBody(payload) {
     err.status = 400
     throw err
   }
+  const mode = payload?.mode === 'multi' ? 'multi' : 'single'
+  if (mode === 'multi' || (Array.isArray(payload?.options) && payload.options.length > 0)) {
+    const rawOptions = Array.isArray(payload?.options) ? payload.options : (Array.isArray(payload?.buttons) ? payload.buttons : [])
+    if (!rawOptions.length || (Array.isArray(rawOptions[0]) && !rawOptions.some((r) => r.length > 0))) {
+      const err = new Error('ask requires at least one option')
+      err.status = 400
+      throw err
+    }
+    return {
+      text,
+      mode: 'multi',
+      options: rawOptions,
+      selected: Array.isArray(payload?.selected) ? payload.selected.map(String) : [],
+      pageSize: Number(payload?.pageSize) || 6,
+      doneText: payload?.doneText,
+      cancelText: payload?.cancelText,
+    }
+  }
   const buttons = normalizeButtons(payload?.buttons)
   if (!buttons.length || !buttons.some((row) => row.length > 0)) {
     const err = new Error('ask requires at least one button')
     err.status = 400
     throw err
   }
-  return { text, buttons }
+  return { text, mode: 'single', buttons }
 }
 
 export function normalizeProgressBody(payload) {

package/lib/models.js

@@ -0,0 +1,106 @@
+export const MODEL_PAGE_SIZE = 10
+
+export async function listModelCatalog(ctx, fallback = {}) {
+  const result = {
+    providers: [],
+    modelsByProvider: new Map(),
+  }
+
+  // 1. Try ctx.llm if available
+  if (ctx?.llm?.listProviders) {
+    try {
+      const providers = await ctx.llm.listProviders()
+      for (const p of providers || []) {
+        const pId = p.id || p
+        result.providers.push({ id: pId, name: p.name || pId })
+        try {
+          const models = await ctx.llm.listModels(pId)
+          result.modelsByProvider.set(
+            pId,
+            (models || []).map((m) => ({ id: m.id || m, name: m.name || m.id || m }))
+          )
+        } catch {
+          result.modelsByProvider.set(pId, [])
+        }
+      }
+    } catch {}
+  }
+
+  // 2. If no providers from ctx.llm, check settings / fallback
+  if (!result.providers.length && fallback.provider) {
+    result.providers.push({ id: fallback.provider, name: fallback.provider })
+    if (fallback.model) {
+      result.modelsByProvider.set(fallback.provider, [{ id: fallback.model, name: fallback.model }])
+    }
+  }
+
+  return result
+}
+
+// In-memory registry for model picker callback tokens to avoid 64-byte Telegram limit
+const modelIndexStore = new Map()
+let modelIndexCounter = 0
+
+export function storeModelSelection(provider, model) {
+  const key = String(++modelIndexCounter)
+  modelIndexStore.set(key, { provider, model, time: Date.now() })
+  // Cleanup entries older than 1 hour
+  if (modelIndexStore.size > 200) {
+    const cutoff = Date.now() - 3600000
+    for (const [k, v] of modelIndexStore.entries()) {
+      if (v.time < cutoff) modelIndexStore.delete(k)
+    }
+  }
+  return key
+}
+
+export function getStoredModelSelection(key) {
+  return modelIndexStore.get(key)
+}
+
+export function buildProvidersKeyboard(providers, current = {}) {
+  const rows = []
+  for (const p of providers) {
+    const isCurrent = p.id === current.provider
+    rows.push([{
+      text: `${isCurrent ? '✅ ' : '🔹 '}${p.name || p.id}`,
+      callback_data: `mdl:p:${p.id}`,
+    }])
+  }
+  return { inline_keyboard: rows }
+}
+
+export function buildModelsKeyboard(providerId, models, currentModel, page = 0, pageSize = MODEL_PAGE_SIZE) {
+  const totalPages = Math.ceil(models.length / pageSize) || 1
+  const curPage = Math.max(0, Math.min(page, totalPages - 1))
+  const start = curPage * pageSize
+  const pageModels = models.slice(start, start + pageSize)
+
+  const rows = []
+  for (const m of pageModels) {
+    const isCurrent = m.id === currentModel
+    const key = storeModelSelection(providerId, m.id)
+    rows.push([{
+      text: `${isCurrent ? '✅ ' : ''}${m.name || m.id}`,
+      callback_data: `mdl:s:${key}`,
+    }])
+  }
+
+  // Navigation row
+  const navRow = []
+  if (curPage > 0) {
+    navRow.push({ text: '⬅️', callback_data: `mdl:pg:${providerId}:${curPage - 1}` })
+  }
+  if (totalPages > 1) {
+    navRow.push({ text: `${curPage + 1}/${totalPages}`, callback_data: `mdl:cur` })
+  }
+  if (curPage < totalPages - 1) {
+    navRow.push({ text: '➡️', callback_data: `mdl:pg:${providerId}:${curPage + 1}` })
+  }
+  if (navRow.length) rows.push(navRow)
+
+  // Back row
+  rows.push([{ text: '🔙 Назад к провайдерам', callback_data: 'mdl:back' }])
+
+  return { inline_keyboard: rows, page: curPage, totalPages }
+}

package/lib/personas.js

@@ -0,0 +1,98 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+export const BUILTIN_PERSONAS = {
+  default: {
+    id: 'default',
+    name: 'Default',
+    icon: '🤖',
+    description: 'Стандартный универсальный ассистент',
+    instruction: '',
+  },
+  coder: {
+    id: 'coder',
+    name: 'Senior Developer',
+    icon: '💻',
+    description: 'Опытный разработчик: чистый код, архитектура, минимум лишних слов',
+    instruction: 'You are an expert senior software engineer. Provide high-quality, production-ready code with best practices, proper error handling, and concise explanations.',
+  },
+  architect: {
+    id: 'architect',
+    name: 'System Architect',
+    icon: '📐',
+    description: 'Системный архитектор: проектирование, масштабируемость, компромиссы',
+    instruction: 'You are a principal system architect. Focus on high-level architecture, scalability, security, trade-offs, modular design, and clear diagrams.',
+  },
+  reviewer: {
+    id: 'reviewer',
+    name: 'Code Reviewer',
+    icon: '🔍',
+    description: 'Строгий код-ревьюер: поиск багов, безопасность, краевые случаи',
+    instruction: 'You are a meticulous code reviewer. Analyze code for bugs, edge cases, security vulnerabilities, performance bottlenecks, and maintainability.',
+  },
+  writer: {
+    id: 'writer',
+    name: 'Tech Writer',
+    icon: '📝',
+    description: 'Технический писатель: понятные тексты, структура, документация',
+    instruction: 'You are a professional technical writer and editor. Structure information clearly with clean formatting, intuitive language, and thorough documentation.',
+  },
+  translator: {
+    id: 'translator',
+    name: 'Translator',
+    icon: '🌐',
+    description: 'Переводчик: точный перевод с сохранением терминологии',
+    instruction: 'You are an expert translator and localization specialist. Translate accurately while preserving technical context, nuance, and terminology.',
+  },
+  concise: {
+    id: 'concise',
+    name: 'Concise',
+    icon: '⚡',
+    description: 'Лаконичный режим: краткие и емкие ответы без воды',
+    instruction: 'Be extremely concise. Answer directly in 1-3 sentences or short bullet points without unnecessary filler or pleasantries.',
+  },
+}
+
+export function getPersona(id) {
+  if (!id) return BUILTIN_PERSONAS.default
+  const clean = String(id).toLowerCase().trim()
+  return BUILTIN_PERSONAS[clean] || null
+}
+
+export function listPersonas() {
+  return Object.values(BUILTIN_PERSONAS)
+}
+
+export function createPersonaStore(filePath) {
+  let cache = {}
+  try {
+    cache = JSON.parse(readFileSync(filePath, 'utf8'))
+  } catch {}
+
+  function save() {
+    try {
+      mkdirSync(dirname(filePath), { recursive: true })
+      writeFileSync(filePath, JSON.stringify(cache, null, 2), 'utf8')
+    } catch {}
+  }
+
+  return {
+    get(chatId) {
+      if (chatId === undefined || chatId === null) return 'default'
+      return cache[String(chatId)] || 'default'
+    },
+    set(chatId, personaId) {
+      if (chatId === undefined || chatId === null) return
+      const valid = getPersona(personaId)
+      if (valid && valid.id !== 'default') {
+        cache[String(chatId)] = valid.id
+      } else {
+        delete cache[String(chatId)]
+      }
+      save()
+    },
+    all() {
+      return { ...cache }
+    },
+  }
+}

package/lib/scheduler.js

@@ -0,0 +1,135 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import { randomUUID } from 'node:crypto'
+
+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) {
+  if (ms <= 0) return 'сейчас'
+  const sec = Math.ceil(ms / 1000)
+  if (sec < 60) return `${sec} сек`
+  const min = Math.ceil(sec / 60)
+  if (min < 60) return `${min} мин`
+  const hr = Math.floor(min / 60)
+  const remMin = min % 60
+  return remMin ? `${hr} ч ${remMin} мин` : `${hr} ч`
+}
+
+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
+  }
+
+  async function save() {
+    try {
+      await mkdir(dirname(filePath), { recursive: true })
+      await writeFile(filePath, JSON.stringify(tasks, null, 2), 'utf8')
+    } 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) {
+      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,
+      dueAt: taskData.dueAt,
+      createdAt: Date.now(),
+      status: 'pending',
+    }
+    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 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,
+    cancel,
+    checkDue,
+    getTasks: () => tasks,
+  }
+}

package/lib/session-ops.js

@@ -0,0 +1,95 @@
+export function exportSessionToMarkdown(session, opts = {}) {
+  if (!session) return { filename: 'session-export.md', content: '# Empty session\n', buffer: Buffer.from('# Empty session\n') }
+
+  const id = session.id || 'unknown'
+  const dateStr = new Date().toISOString().replace(/[:.]/g, '-')
+  const filename = `session-${id}-${dateStr}.md`
+
+  const lines = [
+    `# Export of Session: ${id}`,
+    `*Generated on: ${new Date().toLocaleString()}*`,
+    '',
+    '---',
+    '',
+  ]
+
+  const messages = Array.isArray(session.messages)
+    ? session.messages
+    : (Array.isArray(session.history) ? session.history : [])
+
+  if (!messages.length) {
+    lines.push('*(No messages in this session)*\n')
+  }
+
+  for (const msg of messages) {
+    const role = msg.role || (msg.type === 'user' ? 'user' : 'assistant')
+    const time = msg.createdAt ? new Date(msg.createdAt).toLocaleTimeString() : ''
+    const timeStr = time ? ` (${time})` : ''
+
+    if (role === 'user') {
+      lines.push(`### 👤 User${timeStr}`)
+    } else if (role === 'assistant') {
+      lines.push(`### 🤖 Assistant${timeStr}`)
+    } else if (role === 'system') {
+      lines.push(`### ⚙️ System${timeStr}`)
+    } else {
+      lines.push(`### 💬 ${role}${timeStr}`)
+    }
+
+    let textContent = ''
+    if (typeof msg.content === 'string') {
+      textContent = msg.content
+    } else if (Array.isArray(msg.content)) {
+      textContent = msg.content
+        .map((part) => {
+          if (typeof part === 'string') return part
+          if (part?.text) return part.text
+          if (part?.type === 'text') return part.text
+          if (part?.type === 'tool_use' || part?.tool) {
+            return `\n> 🛠️ **Tool call:** \`${part.name || part.tool}\`\n`
+          }
+          return ''
+        })
+        .filter(Boolean)
+        .join('\n')
+    } else if (msg.text) {
+      textContent = msg.text
+    }
+
+    lines.push(textContent || '*(empty message)*')
+    lines.push('')
+  }
+
+  const content = lines.join('\n')
+  return {
+    filename,
+    content,
+    buffer: Buffer.from(content, 'utf8'),
+    messagesCount: messages.length,
+  }
+}
+
+export function rewindSession(session, turnsCount = 1) {
+  if (!session) return { removed: 0, remaining: 0 }
+  const count = Math.max(1, Number(turnsCount) || 1)
+  const messages = Array.isArray(session.messages) ? session.messages : []
+  if (!messages.length) return { removed: 0, remaining: 0 }
+
+  let toRemove = 0
+  let userTurnsSeen = 0
+
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]
+    toRemove++
+    if (msg.role === 'user' || msg.type === 'user') {
+      userTurnsSeen++
+      if (userTurnsSeen >= count) break
+    }
+  }
+
+  const removed = messages.splice(messages.length - toRemove, toRemove)
+  return {
+    removed: removed.length,
+    remaining: messages.length,
+  }
+}

package/lib/tts.js

@@ -19,8 +19,26 @@ export function stripMarkdownForSpeech(text) {
     .trim()
 }
 
-export function prepareTtsText(answer, maxChars = DEFAULT_TTS_MAX_CHARS) {
-  const stripped = stripMarkdownForSpeech(answer)
+export function prepareVoiceSummary(text, maxChars = 300) {
+  const stripped = stripMarkdownForSpeech(text)
+  if (!stripped) return ''
+  const sentences = stripped.split(/(?<=[.!?])\s+/)
+  let summary = ''
+  for (const s of sentences) {
+    if ((summary + ' ' + s).trim().length <= maxChars) {
+      summary = (summary ? summary + ' ' + s : s).trim()
+    } else {
+      break
+    }
+  }
+  if (!summary) summary = stripped.slice(0, maxChars).trim()
+  return summary
+}
+
+export function prepareTtsText(answer, maxChars = DEFAULT_TTS_MAX_CHARS, opts = {}) {
+  const isSummary = opts.voiceSummary === true
+  const source = isSummary ? prepareVoiceSummary(answer, Math.min(Number(maxChars) || 300, 400)) : answer
+  const stripped = stripMarkdownForSpeech(source)
   if (!stripped || stripped.length < 2) return ''
   const limit = Math.max(1, Number(maxChars) || DEFAULT_TTS_MAX_CHARS)
   return stripped.slice(0, limit)

package/package.json

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