@goodandready/dsh-messenger-gateway 0.3.1 → 0.3.8

package/lib/index.js

@@ -1,6 +1,5 @@
 import { homedir } from 'node:os'
 import { join } from 'node:path'
-import { settingsNamespace } from '@deepseek-ai/dsh-settings'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import { Gateway } from './gateway.js'
 import { readBody, writeJson, isTrustedSettingsRequest } from './http.js'
@@ -14,7 +13,7 @@ import { Config } from './config.js'
 export const name = 'dsh-messenger-gateway'
 export const inject = ['agentDefaultModel', 'agents', 'sessions', 'loader', 'settings', 'webServer', 'attachments', 'tools']
 
-export const SETTINGS_NAMESPACE = settingsNamespace('dsh-messenger-gateway')
+export const SETTINGS_NAMESPACE = 'dsh-messenger-gateway'
 export { Config }
 
 function resolveConfig(raw) {
@@ -53,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'],
@@ -168,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: {
@@ -186,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' },
           },
@@ -193,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'}`,
         }],
       },
@@ -201,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) }
         }
@@ -278,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-messenger-gateway",
-  "version": "0.3.1",
+  "version": "0.3.8",
   "description": "Telegram messenger bridge for DeepSeek Harness: sessions, steer, homes, inline asks, notify bridge, and optional TTS voice notes.",
   "license": "MIT",
   "type": "module",
@@ -51,15 +51,15 @@
     }
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-agent-loop": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
-    "@deepseek-ai/schemastery": "^3.18.1",
-    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-agent": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-agent-loop": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-llm": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-settings": "^0.1.2-alpha.2",
+    "@deepseek-ai/schemastery": "^3.18.2",
+    "@deepseek-ai/dsh-tools": "^0.1.2-alpha.2"
   },
   "publishConfig": {
     "access": "public"