@geekbeer/minion 2.44.0 → 2.48.1

package/core/routes/variables.js

@@ -0,0 +1,131 @@
+/**
+ * Variables & Secrets routes (shared between Linux and Windows)
+ *
+ * Minion Variables:
+ *   GET    /api/variables           - List all variables (key + value)
+ *   GET    /api/variables/:key      - Get a single variable
+ *   PUT    /api/variables/:key      - Set a variable
+ *   DELETE /api/variables/:key      - Delete a variable
+ *
+ * Minion Secrets:
+ *   GET    /api/secrets             - List secret keys only (no values)
+ *   PUT    /api/secrets/:key        - Set a secret
+ *   DELETE /api/secrets/:key        - Delete a secret
+ *
+ * All endpoints require Bearer token authentication.
+ */
+
+const variableStore = require('../stores/variable-store')
+const { verifyToken } = require('../lib/auth')
+
+/** Validate a key name: alphanumeric + underscores, 1-100 chars */
+function isValidKey(key) {
+  return /^[A-Za-z_][A-Za-z0-9_]{0,99}$/.test(key)
+}
+
+/** Validate a value: no newlines, max 2000 chars */
+function isValidValue(value) {
+  if (typeof value !== 'string') return false
+  if (value.includes('\n') || value.includes('\r')) return false
+  if (value.length > 2000) return false
+  return true
+}
+
+function variableRoutes(fastify, _opts, done) {
+  // ─── Variables (non-sensitive) ───────────────────────────────────────
+
+  fastify.get('/api/variables', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const variables = variableStore.getAll('variables')
+    return { success: true, variables }
+  })
+
+  fastify.get('/api/variables/:key', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const { key } = request.params
+    const value = variableStore.get('variables', key)
+    if (value === null) {
+      return reply.code(404).send({ error: `Variable not found: ${key}` })
+    }
+    return { success: true, key, value }
+  })
+
+  fastify.put('/api/variables/:key', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const { key } = request.params
+    const { value } = request.body || {}
+
+    if (!isValidKey(key)) {
+      return reply.code(400).send({ error: 'Invalid key. Use alphanumeric characters and underscores (1-100 chars).' })
+    }
+    if (!isValidValue(value)) {
+      return reply.code(400).send({ error: 'Invalid value. Must be a string, no newlines, max 2000 chars.' })
+    }
+
+    variableStore.set('variables', key, value)
+    return { success: true, key, value }
+  })
+
+  fastify.delete('/api/variables/:key', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const { key } = request.params
+    const removed = variableStore.remove('variables', key)
+    if (!removed) {
+      return reply.code(404).send({ error: `Variable not found: ${key}` })
+    }
+    return { success: true, key }
+  })
+
+  // ─── Secrets (sensitive) ─────────────────────────────────────────────
+
+  fastify.get('/api/secrets', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    // Return keys only — never expose secret values via API
+    const keys = variableStore.listKeys('secrets')
+    return { success: true, keys }
+  })
+
+  fastify.put('/api/secrets/:key', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const { key } = request.params
+    const { value } = request.body || {}
+
+    if (!isValidKey(key)) {
+      return reply.code(400).send({ error: 'Invalid key. Use alphanumeric characters and underscores (1-100 chars).' })
+    }
+    if (!isValidValue(value)) {
+      return reply.code(400).send({ error: 'Invalid value. Must be a string, no newlines, max 2000 chars.' })
+    }
+
+    variableStore.set('secrets', key, value)
+    return { success: true, key }
+  })
+
+  fastify.delete('/api/secrets/:key', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const { key } = request.params
+    const removed = variableStore.remove('secrets', key)
+    if (!removed) {
+      return reply.code(404).send({ error: `Secret not found: ${key}` })
+    }
+    return { success: true, key }
+  })
+
+  done()
+}
+
+module.exports = { variableRoutes }

package/core/stores/daily-log-store.js

@@ -0,0 +1,182 @@
+/**
+ * Daily Log Store
+ * Stores daily conversation summaries as markdown files.
+ * One file per day: $DATA_DIR/daily-logs/YYYY-MM-DD.md
+ *
+ * These logs serve as short-term memory (recent days),
+ * bridging working memory (chat session) and long-term memory (memory-store).
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+
+const { config } = require('../config')
+const { DATA_DIR } = require('../lib/platform')
+
+/**
+ * Resolve daily logs directory path
+ */
+function getLogsDir() {
+  try {
+    require('fs').accessSync(DATA_DIR)
+    return path.join(DATA_DIR, 'daily-logs')
+  } catch {
+    return path.join(config.HOME_DIR, 'daily-logs')
+  }
+}
+
+const LOGS_DIR = getLogsDir()
+
+/**
+ * Ensure the daily-logs directory exists
+ */
+async function ensureDir() {
+  await fs.mkdir(LOGS_DIR, { recursive: true })
+}
+
+/**
+ * Validate date string format (YYYY-MM-DD)
+ */
+function isValidDate(date) {
+  return /^\d{4}-\d{2}-\d{2}$/.test(date)
+}
+
+/**
+ * List all daily logs with date and file size.
+ * @returns {Promise<Array<{ date: string, size: number }>>} Sorted descending by date
+ */
+async function listLogs() {
+  await ensureDir()
+  let files
+  try {
+    files = await fs.readdir(LOGS_DIR)
+  } catch {
+    return []
+  }
+
+  const logs = []
+  for (const file of files) {
+    if (!file.endsWith('.md')) continue
+    const date = file.replace('.md', '')
+    if (!isValidDate(date)) continue
+    try {
+      const stat = await fs.stat(path.join(LOGS_DIR, file))
+      logs.push({ date, size: stat.size })
+    } catch {
+      // Skip unreadable
+    }
+  }
+
+  // Sort by date descending (most recent first)
+  logs.sort((a, b) => b.date.localeCompare(a.date))
+  return logs
+}
+
+/**
+ * Load a specific day's log.
+ * @param {string} date - YYYY-MM-DD format
+ * @returns {Promise<string|null>} Log content or null
+ */
+async function loadLog(date) {
+  if (!isValidDate(date)) return null
+  try {
+    return await fs.readFile(path.join(LOGS_DIR, `${date}.md`), 'utf-8')
+  } catch (err) {
+    if (err.code === 'ENOENT') return null
+    console.error(`[DailyLogStore] Failed to load log ${date}: ${err.message}`)
+    return null
+  }
+}
+
+/**
+ * Save a daily log. Overwrites existing log for the same date.
+ * @param {string} date - YYYY-MM-DD format
+ * @param {string} content - Markdown content
+ */
+async function saveLog(date, content) {
+  if (!isValidDate(date)) {
+    throw new Error(`Invalid date format: ${date}. Expected YYYY-MM-DD.`)
+  }
+  await ensureDir()
+  await fs.writeFile(path.join(LOGS_DIR, `${date}.md`), content, 'utf-8')
+}
+
+/**
+ * Delete a daily log.
+ * @param {string} date - YYYY-MM-DD format
+ * @returns {Promise<boolean>}
+ */
+async function deleteLog(date) {
+  if (!isValidDate(date)) return false
+  try {
+    await fs.unlink(path.join(LOGS_DIR, `${date}.md`))
+    return true
+  } catch (err) {
+    if (err.code === 'ENOENT') return false
+    console.error(`[DailyLogStore] Failed to delete log ${date}: ${err.message}`)
+    return false
+  }
+}
+
+/**
+ * Get the most recent N days of logs.
+ * @param {number} days - Number of recent days to fetch
+ * @returns {Promise<Array<{ date: string, content: string }>>}
+ */
+async function getRecentLogs(days = 3) {
+  const all = await listLogs()
+  const recent = all.slice(0, days)
+
+  const results = []
+  for (const { date } of recent) {
+    const content = await loadLog(date)
+    if (content) {
+      results.push({ date, content })
+    }
+  }
+  return results
+}
+
+/**
+ * Get a context snippet of recent daily logs for chat injection.
+ * @param {number} days - Number of days to include
+ * @param {number} maxChars - Maximum total characters
+ * @returns {Promise<string>}
+ */
+async function getContextSnippet(days = 3, maxChars = 1500) {
+  const logs = await getRecentLogs(days)
+  if (logs.length === 0) return ''
+
+  const parts = []
+  let totalLen = 0
+
+  for (const log of logs) {
+    const header = `### ${log.date}`
+    const content = log.content.substring(0, Math.floor(maxChars / days))
+    const section = `${header}\n${content}`
+
+    if (totalLen + section.length > maxChars) {
+      // Add truncated version
+      const remaining = maxChars - totalLen
+      if (remaining > 50) {
+        parts.push(section.substring(0, remaining) + '...')
+      }
+      break
+    }
+    parts.push(section)
+    totalLen += section.length + 2
+  }
+
+  return parts.join('\n\n')
+}
+
+module.exports = {
+  ensureDir,
+  listLogs,
+  loadLog,
+  saveLog,
+  deleteLog,
+  getRecentLogs,
+  getContextSnippet,
+  LOGS_DIR,
+}

package/core/stores/memory-store.js

@@ -0,0 +1,256 @@
+/**
+ * Memory Store
+ * Persistent long-term memory for the minion, stored as markdown files.
+ * Each entry has YAML frontmatter (id, title, category, timestamps) + body.
+ * An index file (MEMORY.md) provides a quick summary of all entries.
+ *
+ * Storage layout:
+ *   $DATA_DIR/memory/
+ *   ├── MEMORY.md          # Index (auto-generated)
+ *   └── {id}.md            # Individual entries
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const crypto = require('crypto')
+
+const { config } = require('../config')
+const { DATA_DIR } = require('../lib/platform')
+
+const VALID_CATEGORIES = ['user', 'feedback', 'project', 'reference']
+
+/**
+ * Resolve memory directory path
+ */
+function getMemoryDir() {
+  try {
+    require('fs').accessSync(DATA_DIR)
+    return path.join(DATA_DIR, 'memory')
+  } catch {
+    return path.join(config.HOME_DIR, 'memory')
+  }
+}
+
+const MEMORY_DIR = getMemoryDir()
+const INDEX_FILE = path.join(MEMORY_DIR, 'MEMORY.md')
+
+/**
+ * Ensure the memory directory exists
+ */
+async function ensureDir() {
+  await fs.mkdir(MEMORY_DIR, { recursive: true })
+}
+
+/**
+ * Parse YAML-style frontmatter from markdown content.
+ * Returns { meta: {}, body: '' }
+ */
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/)
+  if (!match) return { meta: {}, body: content }
+
+  const meta = {}
+  for (const line of match[1].split('\n')) {
+    const idx = line.indexOf(':')
+    if (idx === -1) continue
+    const key = line.slice(0, idx).trim()
+    const value = line.slice(idx + 1).trim()
+    meta[key] = value
+  }
+  return { meta, body: match[2].trim() }
+}
+
+/**
+ * Serialize entry to markdown with YAML frontmatter
+ */
+function serializeEntry(entry) {
+  const lines = [
+    '---',
+    `id: ${entry.id}`,
+    `title: ${entry.title}`,
+    `category: ${entry.category}`,
+    `created_at: ${entry.created_at}`,
+    `updated_at: ${entry.updated_at}`,
+    '---',
+    '',
+    entry.content || '',
+  ]
+  return lines.join('\n')
+}
+
+/**
+ * List all memory entries (frontmatter only, no body).
+ * @returns {Promise<Array<{ id, title, category, created_at, updated_at }>>}
+ */
+async function listEntries() {
+  await ensureDir()
+  let files
+  try {
+    files = await fs.readdir(MEMORY_DIR)
+  } catch {
+    return []
+  }
+
+  const entries = []
+  for (const file of files) {
+    if (file === 'MEMORY.md' || !file.endsWith('.md')) continue
+    try {
+      const raw = await fs.readFile(path.join(MEMORY_DIR, file), 'utf-8')
+      const { meta, body } = parseFrontmatter(raw)
+      if (meta.id) {
+        entries.push({
+          id: meta.id,
+          title: meta.title || '',
+          category: meta.category || 'reference',
+          created_at: meta.created_at || '',
+          updated_at: meta.updated_at || '',
+          excerpt: body.substring(0, 200),
+        })
+      }
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  // Sort by updated_at descending
+  entries.sort((a, b) => (b.updated_at || '').localeCompare(a.updated_at || ''))
+  return entries
+}
+
+/**
+ * Load a single memory entry by ID.
+ * @param {string} id
+ * @returns {Promise<object|null>}
+ */
+async function loadEntry(id) {
+  try {
+    const raw = await fs.readFile(path.join(MEMORY_DIR, `${id}.md`), 'utf-8')
+    const { meta, body } = parseFrontmatter(raw)
+    return {
+      id: meta.id || id,
+      title: meta.title || '',
+      category: meta.category || 'reference',
+      content: body,
+      created_at: meta.created_at || '',
+      updated_at: meta.updated_at || '',
+    }
+  } catch (err) {
+    if (err.code === 'ENOENT') return null
+    console.error(`[MemoryStore] Failed to load entry ${id}: ${err.message}`)
+    return null
+  }
+}
+
+/**
+ * Save (create or update) a memory entry.
+ * @param {{ id?, title, category, content }} entry
+ * @returns {Promise<object>} The saved entry
+ */
+async function saveEntry(entry) {
+  await ensureDir()
+
+  const now = new Date().toISOString()
+  const id = entry.id || crypto.randomBytes(6).toString('hex')
+  const category = VALID_CATEGORIES.includes(entry.category) ? entry.category : 'reference'
+
+  // Check if existing
+  const existing = await loadEntry(id)
+
+  const full = {
+    id,
+    title: entry.title || 'Untitled',
+    category,
+    content: entry.content || '',
+    created_at: existing ? existing.created_at : now,
+    updated_at: now,
+  }
+
+  const md = serializeEntry(full)
+  await fs.writeFile(path.join(MEMORY_DIR, `${id}.md`), md, 'utf-8')
+
+  // Regenerate index
+  await regenerateIndex()
+
+  return full
+}
+
+/**
+ * Delete a memory entry.
+ * @param {string} id
+ * @returns {Promise<boolean>}
+ */
+async function deleteEntry(id) {
+  try {
+    await fs.unlink(path.join(MEMORY_DIR, `${id}.md`))
+    await regenerateIndex()
+    return true
+  } catch (err) {
+    if (err.code === 'ENOENT') return false
+    console.error(`[MemoryStore] Failed to delete entry ${id}: ${err.message}`)
+    return false
+  }
+}
+
+/**
+ * Regenerate MEMORY.md index file from all entries.
+ */
+async function regenerateIndex() {
+  const entries = await listEntries()
+  const lines = ['# Minion Memory', '']
+
+  if (entries.length === 0) {
+    lines.push('No memories stored yet.')
+  } else {
+    // Group by category
+    const grouped = {}
+    for (const e of entries) {
+      const cat = e.category || 'reference'
+      if (!grouped[cat]) grouped[cat] = []
+      grouped[cat].push(e)
+    }
+
+    for (const cat of VALID_CATEGORIES) {
+      if (!grouped[cat] || grouped[cat].length === 0) continue
+      lines.push(`## ${cat}`, '')
+      for (const e of grouped[cat]) {
+        lines.push(`- **${e.title}** (${e.id}) - ${e.excerpt.substring(0, 80)}`)
+      }
+      lines.push('')
+    }
+  }
+
+  await fs.writeFile(INDEX_FILE, lines.join('\n'), 'utf-8')
+}
+
+/**
+ * Get a context snippet suitable for chat injection.
+ * Returns the most important memory entries as a formatted string.
+ * @param {number} maxChars - Maximum characters to return
+ * @returns {Promise<string>}
+ */
+async function getContextSnippet(maxChars = 2000) {
+  const entries = await listEntries()
+  if (entries.length === 0) return ''
+
+  const parts = []
+  let totalLen = 0
+
+  for (const e of entries) {
+    const line = `[${e.category}] ${e.title}: ${e.excerpt}`
+    if (totalLen + line.length > maxChars) break
+    parts.push(line)
+    totalLen += line.length + 1
+  }
+
+  return parts.join('\n')
+}
+
+module.exports = {
+  ensureDir,
+  listEntries,
+  loadEntry,
+  saveEntry,
+  deleteEntry,
+  getContextSnippet,
+  MEMORY_DIR,
+}