@vox-ai-app/storage 1.0.2 → 1.0.3

package/src/repos/messages.js

@@ -0,0 +1,219 @@
+import { randomUUID } from 'crypto'
+
+export const DEFAULT_CONVERSATION_ID = 'main'
+
+function getConversationId(conversationId) {
+  if (!conversationId) return DEFAULT_CONVERSATION_ID
+  const normalized = String(conversationId).trim()
+  if (!normalized) throw new Error('conversationId cannot be an empty string')
+  return normalized
+}
+
+function normalizeLimit(limit) {
+  const parsed = Number.parseInt(limit, 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null
+}
+
+function mapRow(row) {
+  if (!row) return null
+  return {
+    id: row.id,
+    sortOrder: row.sort_order,
+    conversationId: row.conversation_id,
+    role: row.role,
+    content: row.content,
+    tokens: row.tokens ?? null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  }
+}
+
+export function ensureConversation(db, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  const now = new Date().toISOString()
+
+  db.prepare(
+    `INSERT INTO conversations (id, created_at, updated_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(id) DO NOTHING`
+  ).run(id, now, now)
+
+  return db
+    .prepare(
+      `SELECT id, title, user_info, context_summary, context_checkpoint_id, created_at, updated_at FROM conversations WHERE id = ?`
+    )
+    .get(id)
+}
+
+export function touchConversation(db, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  const now = new Date().toISOString()
+
+  db.prepare(
+    `INSERT INTO conversations (id, created_at, updated_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET updated_at = excluded.updated_at`
+  ).run(id, now, now)
+
+  return db
+    .prepare(
+      `SELECT id, title, user_info, context_summary, context_checkpoint_id, created_at, updated_at FROM conversations WHERE id = ?`
+    )
+    .get(id)
+}
+
+export function appendMessage(
+  db,
+  role,
+  content,
+  conversationId = DEFAULT_CONVERSATION_ID,
+  tokens = null
+) {
+  const convId = getConversationId(conversationId)
+  const msgId = randomUUID()
+  const now = new Date().toISOString()
+  if (!role) throw new Error('role is required')
+  const normalizedRole = String(role).trim()
+  if (!normalizedRole) throw new Error('role cannot be empty')
+  const normalizedContent = String(content ?? '')
+
+  touchConversation(db, convId)
+
+  db.prepare(
+    `INSERT INTO messages (id, conversation_id, role, content, tokens, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(msgId, convId, normalizedRole, normalizedContent, tokens, now, now)
+
+  return mapRow(
+    db
+      .prepare(
+        `SELECT sort_order, id, conversation_id, role, content, tokens, created_at, updated_at
+       FROM messages WHERE id = ?`
+      )
+      .get(msgId)
+  )
+}
+
+export function getMessages(db, conversationId = DEFAULT_CONVERSATION_ID, limit) {
+  const id = getConversationId(conversationId)
+  const normalizedLimit = normalizeLimit(limit)
+
+  if (!normalizedLimit) {
+    return db
+      .prepare(
+        `SELECT sort_order, id, conversation_id, role, content, tokens, created_at, updated_at
+         FROM messages
+         WHERE conversation_id = ?
+         ORDER BY sort_order ASC`
+      )
+      .all(id)
+      .map(mapRow)
+  }
+
+  return db
+    .prepare(
+      `SELECT sort_order, id, conversation_id, role, content, tokens, created_at, updated_at
+       FROM (
+         SELECT sort_order, id, conversation_id, role, content, tokens, created_at, updated_at
+         FROM messages
+         WHERE conversation_id = ?
+         ORDER BY sort_order DESC
+         LIMIT ?
+       )
+       ORDER BY sort_order ASC`
+    )
+    .all(id, normalizedLimit)
+    .map(mapRow)
+}
+
+export function getMessagesBeforeId(
+  db,
+  beforeId,
+  conversationId = DEFAULT_CONVERSATION_ID,
+  limit = 50
+) {
+  const convId = getConversationId(conversationId)
+  const normalizedLimit = normalizeLimit(limit)
+  if (!normalizedLimit) throw new Error('limit must be a positive integer')
+
+  if (!beforeId) return []
+  const normalizedBeforeId = String(beforeId).trim()
+  if (!normalizedBeforeId) return []
+
+  const anchor = db
+    .prepare(`SELECT sort_order FROM messages WHERE id = ? AND conversation_id = ?`)
+    .get(normalizedBeforeId, convId)
+
+  if (!anchor) return []
+
+  return db
+    .prepare(
+      `SELECT sort_order, id, conversation_id, role, content, tokens, created_at, updated_at
+       FROM (
+         SELECT sort_order, id, conversation_id, role, content, tokens, created_at, updated_at
+         FROM messages
+         WHERE conversation_id = ? AND sort_order < ?
+         ORDER BY sort_order DESC
+         LIMIT ?
+       )
+       ORDER BY sort_order ASC`
+    )
+    .all(convId, anchor.sort_order, normalizedLimit)
+    .map(mapRow)
+}
+
+export function clearMessages(db, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  ensureConversation(db, id)
+  return db.prepare(`DELETE FROM messages WHERE conversation_id = ?`).run(id)
+}
+
+export function saveSummaryCheckpoint(
+  db,
+  summary,
+  checkpointId,
+  conversationId = DEFAULT_CONVERSATION_ID
+) {
+  const id = getConversationId(conversationId)
+  ensureConversation(db, id)
+  db.prepare(
+    `UPDATE conversations SET context_summary = ?, context_checkpoint_id = ?, updated_at = ? WHERE id = ?`
+  ).run(summary || null, checkpointId || null, new Date().toISOString(), id)
+}
+
+export function loadSummaryCheckpoint(db, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  const row = db
+    .prepare(`SELECT context_summary, context_checkpoint_id FROM conversations WHERE id = ?`)
+    .get(id)
+  if (!row || !row.context_summary) return null
+  return { summary: row.context_summary, checkpointId: row.context_checkpoint_id }
+}
+
+export function clearSummaryCheckpoint(db, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  db.prepare(
+    `UPDATE conversations SET context_summary = NULL, context_checkpoint_id = NULL, updated_at = ? WHERE id = ?`
+  ).run(new Date().toISOString(), id)
+}
+
+export function getConversationUserInfo(db, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  const row = db.prepare(`SELECT user_info FROM conversations WHERE id = ?`).get(id)
+  if (!row) return {}
+  try {
+    return JSON.parse(row.user_info)
+  } catch {
+    return {}
+  }
+}
+
+export function setConversationUserInfo(db, userInfo, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  ensureConversation(db, id)
+  db.prepare(`UPDATE conversations SET user_info = ?, updated_at = ? WHERE id = ?`).run(
+    JSON.stringify(userInfo || {}),
+    new Date().toISOString(),
+    id
+  )
+}

package/src/repos/patterns.js

@@ -0,0 +1,54 @@
+import { randomUUID } from 'crypto'
+
+function mapPattern(row) {
+  if (!row) return null
+  return {
+    id: row.id,
+    taskId: row.task_id || null,
+    trigger: row.trigger,
+    solution: row.solution,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  }
+}
+
+export function insertPattern(db, pattern) {
+  const id = pattern.id || randomUUID()
+  const now = new Date().toISOString()
+
+  db.prepare(
+    `INSERT OR REPLACE INTO knowledge_patterns (id, task_id, trigger, solution, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(id, pattern.taskId || null, String(pattern.trigger), String(pattern.solution), now, now)
+
+  return getPattern(db, id)
+}
+
+export function getPattern(db, id) {
+  return mapPattern(db.prepare(`SELECT * FROM knowledge_patterns WHERE id = ?`).get(id))
+}
+
+export function searchPatternsFts(db, query) {
+  if (!query?.trim()) return []
+  const terms = query
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((t) => `"${t.replace(/"/g, '')}"`)
+    .join(' ')
+  try {
+    return db
+      .prepare(
+        `SELECT p.id, p.task_id, p.trigger, p.solution, p.created_at, p.updated_at
+         FROM patterns_fts f
+         JOIN knowledge_patterns p ON p.id = f.pattern_id
+         WHERE f.patterns_fts MATCH ?
+         ORDER BY bm25(f.patterns_fts)
+         LIMIT 5`
+      )
+      .all(terms)
+      .map(mapPattern)
+  } catch {
+    return []
+  }
+}

package/src/repos/schedules.js

@@ -0,0 +1,58 @@
+import { randomUUID } from 'crypto'
+
+function mapSchedule(row) {
+  if (!row) return null
+  return {
+    id: row.id,
+    cronExpr: row.cron_expr,
+    timezone: row.timezone || null,
+    prompt: row.prompt,
+    channel: row.channel || null,
+    isEnabled: !!row.is_enabled,
+    once: !!row.once,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  }
+}
+
+export function saveSchedule(db, schedule) {
+  const id = schedule.id || randomUUID()
+  const now = new Date().toISOString()
+
+  db.prepare(
+    `INSERT INTO schedules (id, cron_expr, timezone, prompt, channel, is_enabled, once, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       cron_expr = excluded.cron_expr,
+       timezone = excluded.timezone,
+       prompt = excluded.prompt,
+       channel = excluded.channel,
+       is_enabled = excluded.is_enabled,
+       once = excluded.once,
+       updated_at = excluded.updated_at`
+  ).run(
+    id,
+    String(schedule.cronExpr || schedule.expr),
+    schedule.timezone || schedule.tz || null,
+    String(schedule.prompt),
+    schedule.channel || null,
+    schedule.isEnabled === false ? 0 : 1,
+    schedule.once ? 1 : 0,
+    now,
+    now
+  )
+
+  return getSchedule(db, id)
+}
+
+export function removeSchedule(db, id) {
+  return db.prepare(`DELETE FROM schedules WHERE id = ?`).run(id)
+}
+
+export function getSchedule(db, id) {
+  return mapSchedule(db.prepare(`SELECT * FROM schedules WHERE id = ?`).get(id))
+}
+
+export function listSchedules(db) {
+  return db.prepare(`SELECT * FROM schedules ORDER BY created_at ASC`).all().map(mapSchedule)
+}

package/src/repos/settings.js

@@ -0,0 +1,38 @@
+export function getSetting(db, key) {
+  const row = db.prepare(`SELECT value FROM settings WHERE key = ?`).get(key)
+  return row ? row.value : undefined
+}
+
+export function getSettingJson(db, key, fallback = null) {
+  const raw = getSetting(db, key)
+  if (raw === undefined) return fallback
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return fallback
+  }
+}
+
+export function setSetting(db, key, value) {
+  const now = new Date().toISOString()
+  const raw = JSON.stringify(value)
+  db.prepare(
+    `INSERT INTO settings (key, value, updated_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
+  ).run(key, raw, now)
+  return value
+}
+
+export function deleteSetting(db, key) {
+  return db.prepare(`DELETE FROM settings WHERE key = ?`).run(key).changes > 0
+}
+
+export function getAllSettings(db) {
+  const rows = db.prepare(`SELECT key, value FROM settings`).all()
+  const result = {}
+  for (const row of rows) {
+    result[row.key] = row.value
+  }
+  return result
+}

package/src/repos/tasks.js

@@ -0,0 +1,195 @@
+function parseJson(value, fallback) {
+  if (value === null || value === undefined || value === '') return fallback
+  try {
+    return JSON.parse(value)
+  } catch {
+    return fallback
+  }
+}
+
+function stringifyJson(value, fallback = null) {
+  if (value === null || value === undefined) return fallback
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return fallback
+  }
+}
+
+function mapTask(row) {
+  if (!row) return null
+  return {
+    id: row.id,
+    instructions: row.instructions,
+    context: row.context,
+    status: row.status,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    currentPlan: row.current_plan,
+    result: row.result,
+    error: row.error || null,
+    abortReason: row.abort_reason || null,
+    provider: row.provider || null,
+    model: row.model || null,
+    contextInjected: !!row.context_injected,
+    completedAt: row.completed_at || null
+  }
+}
+
+function mapActivity(row) {
+  if (!row) return null
+  return {
+    id: row.id,
+    taskId: row.task_id,
+    type: row.type,
+    name: row.name || null,
+    args: parseJson(row.args, row.args),
+    result: parseJson(row.result, row.result),
+    plan: row.plan || null,
+    createdAt: row.created_at,
+    data: parseJson(row.data, {})
+  }
+}
+
+export function upsertTask(db, task) {
+  const id = String(task?.id || '').trim()
+  if (!id) throw new Error('task id is required.')
+
+  const createdAt = String(task?.createdAt || new Date().toISOString())
+  const updatedAt = String(task?.updatedAt || new Date().toISOString())
+
+  db.prepare(
+    `INSERT INTO tasks (
+      id, instructions, context, status, created_at, updated_at,
+      current_plan, result, error, abort_reason, provider, model,
+      context_injected, completed_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      instructions = excluded.instructions,
+      context = excluded.context,
+      status = excluded.status,
+      updated_at = excluded.updated_at,
+      current_plan = excluded.current_plan,
+      result = excluded.result,
+      error = excluded.error,
+      abort_reason = excluded.abort_reason,
+      provider = excluded.provider,
+      model = excluded.model,
+      context_injected = excluded.context_injected,
+      completed_at = excluded.completed_at`
+  ).run(
+    id,
+    String(task?.instructions || ''),
+    String(task?.context || ''),
+    String(task?.status || 'queued'),
+    createdAt,
+    updatedAt,
+    String(task?.currentPlan || ''),
+    task?.result == null ? null : String(task.result),
+    task?.error == null ? null : String(task.error),
+    task?.abortReason == null ? null : String(task.abortReason),
+    task?.provider == null ? null : String(task.provider),
+    task?.model == null ? null : String(task.model),
+    task?.contextInjected ? 1 : 0,
+    task?.completedAt == null ? null : String(task.completedAt)
+  )
+
+  return getTask(db, id)
+}
+
+export function getTask(db, id) {
+  return mapTask(
+    db
+      .prepare(
+        `SELECT id, instructions, context, status, created_at, updated_at,
+              current_plan, result, error, abort_reason, provider, model,
+              context_injected, completed_at
+       FROM tasks WHERE id = ?`
+      )
+      .get(String(id || '').trim())
+  )
+}
+
+export function loadTasks(db) {
+  return db
+    .prepare(
+      `SELECT id, instructions, context, status, created_at, updated_at,
+              current_plan, result, error, abort_reason, provider, model,
+              context_injected, completed_at
+       FROM tasks
+       ORDER BY created_at DESC, id DESC`
+    )
+    .all()
+    .map(mapTask)
+}
+
+export function appendTaskActivity(db, activity) {
+  const id = String(activity?.id ?? '').trim()
+  const taskId = String(activity?.taskId ?? '').trim()
+  if (!id || !taskId) throw new Error('Task activity requires id and taskId.')
+
+  const VALID_TYPES = new Set([
+    'tool_call',
+    'tool_result',
+    'text',
+    'thought',
+    'journal',
+    'spawn',
+    'error'
+  ])
+  const type = String(activity?.type ?? '')
+  if (!VALID_TYPES.has(type)) throw new Error(`Invalid task activity type: "${type}"`)
+
+  db.prepare(
+    `INSERT INTO task_activity (id, task_id, type, name, args, result, plan, data, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       task_id = excluded.task_id,
+       type = excluded.type,
+       name = excluded.name,
+       args = excluded.args,
+       result = excluded.result,
+       plan = excluded.plan,
+       data = excluded.data,
+       created_at = excluded.created_at`
+  ).run(
+    id,
+    taskId,
+    type,
+    activity?.name ? String(activity.name) : null,
+    activity?.args ? String(activity.args) : null,
+    stringifyJson(
+      activity?.result,
+      activity?.result === undefined ? null : String(activity.result)
+    ),
+    activity?.plan ? String(activity.plan) : null,
+    stringifyJson(activity?.data ?? {}, '{}'),
+    String(activity?.createdAt ?? new Date().toISOString())
+  )
+
+  return id
+}
+
+export function loadTaskActivity(db, taskId) {
+  return db
+    .prepare(
+      `SELECT id, task_id, type, name, args, result, plan, data, created_at
+       FROM task_activity
+       WHERE task_id = ?
+       ORDER BY created_at ASC, id ASC`
+    )
+    .all(String(taskId || '').trim())
+    .map(mapActivity)
+}
+
+export function loadAllTaskActivity(db) {
+  return db
+    .prepare(
+      `SELECT id, task_id, type, name, args, result, plan, data, created_at
+       FROM task_activity
+       ORDER BY created_at ASC, id ASC`
+    )
+    .all()
+    .map(mapActivity)
+}

package/src/repos/tool-secrets.js

@@ -0,0 +1,26 @@
+import { randomUUID } from 'crypto'
+
+export function setToolSecret(db, toolId, key, encryptedValue) {
+  const now = new Date().toISOString()
+  const id = randomUUID()
+
+  db.prepare(
+    `INSERT INTO tool_secrets (id, tool_id, key, encrypted_value, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(tool_id, key) DO UPDATE SET
+       encrypted_value = excluded.encrypted_value,
+       updated_at = excluded.updated_at`
+  ).run(id, toolId, key, encryptedValue, now, now)
+}
+
+export function getToolSecrets(db, toolId) {
+  return db.prepare(`SELECT key, encrypted_value FROM tool_secrets WHERE tool_id = ?`).all(toolId)
+}
+
+export function deleteToolSecret(db, toolId, key) {
+  return db.prepare(`DELETE FROM tool_secrets WHERE tool_id = ? AND key = ?`).run(toolId, key)
+}
+
+export function deleteAllToolSecrets(db, toolId) {
+  return db.prepare(`DELETE FROM tool_secrets WHERE tool_id = ?`).run(toolId)
+}

package/src/repos/tools.js

@@ -0,0 +1,104 @@
+import { randomUUID } from 'crypto'
+
+function mapTool(row) {
+  if (!row) return null
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    parameters: JSON.parse(row.parameters),
+    sourceType: row.source_type,
+    sourceCode: row.source_code || null,
+    webhookUrl: row.webhook_url || null,
+    webhookHeaders: JSON.parse(row.webhook_headers),
+    isEnabled: !!row.is_enabled,
+    tags: JSON.parse(row.tags),
+    version: row.version,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  }
+}
+
+export function createTool(db, tool) {
+  const id = tool.id || randomUUID()
+  const now = new Date().toISOString()
+
+  db.prepare(
+    `INSERT INTO tools (id, name, description, parameters, source_type, source_code,
+      webhook_url, webhook_headers, is_enabled, tags, version, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    String(tool.name),
+    String(tool.description || ''),
+    JSON.stringify(tool.parameters || { type: 'object', properties: {} }),
+    String(tool.sourceType || 'js_function'),
+    tool.sourceCode || null,
+    tool.webhookUrl || null,
+    JSON.stringify(tool.webhookHeaders || {}),
+    tool.isEnabled === false ? 0 : 1,
+    JSON.stringify(tool.tags || []),
+    tool.version || 1,
+    now,
+    now
+  )
+
+  return getTool(db, id)
+}
+
+export function updateTool(db, id, updates) {
+  const existing = getTool(db, id)
+  if (!existing) return null
+
+  const now = new Date().toISOString()
+  const merged = { ...existing, ...updates, updatedAt: now }
+
+  db.prepare(
+    `UPDATE tools SET name = ?, description = ?, parameters = ?, source_type = ?,
+      source_code = ?, webhook_url = ?, webhook_headers = ?, is_enabled = ?,
+      tags = ?, version = ?, updated_at = ?
+     WHERE id = ?`
+  ).run(
+    String(merged.name),
+    String(merged.description || ''),
+    JSON.stringify(merged.parameters || { type: 'object', properties: {} }),
+    String(merged.sourceType || 'js_function'),
+    merged.sourceCode || null,
+    merged.webhookUrl || null,
+    JSON.stringify(merged.webhookHeaders || {}),
+    merged.isEnabled === false ? 0 : 1,
+    JSON.stringify(merged.tags || []),
+    merged.version || 1,
+    now,
+    id
+  )
+
+  return getTool(db, id)
+}
+
+export function deleteTool(db, id) {
+  return db.prepare(`DELETE FROM tools WHERE id = ?`).run(id)
+}
+
+export function getTool(db, id) {
+  return mapTool(db.prepare(`SELECT * FROM tools WHERE id = ?`).get(id))
+}
+
+export function getToolByName(db, name) {
+  return mapTool(db.prepare(`SELECT * FROM tools WHERE name = ?`).get(name))
+}
+
+export function listTools(db, enabledOnly = false) {
+  if (enabledOnly) {
+    return db.prepare(`SELECT * FROM tools WHERE is_enabled = 1`).all().map(mapTool)
+  }
+  return db.prepare(`SELECT * FROM tools ORDER BY name ASC`).all().map(mapTool)
+}
+
+export function upsertTool(db, tool) {
+  const existing = tool.id ? getTool(db, tool.id) : getToolByName(db, tool.name)
+  if (existing) {
+    return updateTool(db, existing.id, tool)
+  }
+  return createTool(db, tool)
+}