@goodandready/dsh-messenger-gateway 0.3.2 → 0.3.8

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.2",
+  "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",