@yeaft/webchat-agent 1.0.186 → 1.0.189

package/local-runtime/server/db/expert-db.js

@@ -0,0 +1,171 @@
+import { randomUUID } from 'crypto';
+import db from './connection.js';
+import { transaction } from './connection.js';
+
+// Prepared statements
+const stmts = {
+  // Roles
+  insertRole: db.prepare(`
+    INSERT INTO custom_expert_roles (id, user_id, role_id, name, full_name, title, title_en, group_id, icon, message_prefix, message_prefix_en, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `),
+  updateRole: db.prepare(`
+    UPDATE custom_expert_roles
+    SET name = ?, full_name = ?, title = ?, title_en = ?, group_id = ?, icon = ?,
+        message_prefix = ?, message_prefix_en = ?, updated_at = ?
+    WHERE user_id = ? AND role_id = ?
+  `),
+  deleteRole: db.prepare(`
+    DELETE FROM custom_expert_roles WHERE user_id = ? AND role_id = ?
+  `),
+  getRolesByUser: db.prepare(`
+    SELECT * FROM custom_expert_roles WHERE user_id = ? ORDER BY created_at ASC
+  `),
+  getRoleByUserAndId: db.prepare(`
+    SELECT * FROM custom_expert_roles WHERE user_id = ? AND role_id = ?
+  `),
+
+  // Actions
+  insertAction: db.prepare(`
+    INSERT INTO custom_expert_actions (id, role_row_id, action_id, name, name_en, message_template, message_template_en, default_message, default_message_en)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `),
+  deleteActionsByRole: db.prepare(`
+    DELETE FROM custom_expert_actions WHERE role_row_id = ?
+  `),
+  getActionsByRole: db.prepare(`
+    SELECT * FROM custom_expert_actions WHERE role_row_id = ? ORDER BY rowid ASC
+  `)
+};
+
+// Transaction wrappers
+const insertRoleWithActions = transaction((userId, roleData) => {
+  const now = Date.now();
+  const rowId = `cer_${randomUUID()}`;
+  const roleId = roleData.roleId || `custom-${randomUUID().substring(0, 8)}`;
+
+  stmts.insertRole.run(
+    rowId, userId, roleId,
+    roleData.name, roleData.fullName || null,
+    roleData.title, roleData.titleEn || null,
+    roleData.groupId || 'custom', roleData.icon || null,
+    roleData.messagePrefix || null, roleData.messagePrefixEn || null,
+    now, now
+  );
+
+  if (roleData.actions && roleData.actions.length > 0) {
+    for (const action of roleData.actions) {
+      stmts.insertAction.run(
+        `cea_${randomUUID()}`, rowId,
+        action.actionId || action.id,
+        action.name, action.nameEn || null,
+        action.messageTemplate || null, action.messageTemplateEn || null,
+        action.defaultMessage || null, action.defaultMessageEn || null
+      );
+    }
+  }
+
+  return { rowId, roleId };
+});
+
+const updateRoleWithActions = transaction((userId, roleId, roleData) => {
+  const now = Date.now();
+
+  stmts.updateRole.run(
+    roleData.name, roleData.fullName || null,
+    roleData.title, roleData.titleEn || null,
+    roleData.groupId || 'custom', roleData.icon || null,
+    roleData.messagePrefix || null, roleData.messagePrefixEn || null,
+    now, userId, roleId
+  );
+
+  // Get the row id to replace actions
+  const row = stmts.getRoleByUserAndId.get(userId, roleId);
+  if (!row) throw new Error(`Role not found: ${roleId}`);
+
+  // Replace all actions
+  stmts.deleteActionsByRole.run(row.id);
+  if (roleData.actions && roleData.actions.length > 0) {
+    for (const action of roleData.actions) {
+      stmts.insertAction.run(
+        `cea_${randomUUID()}`, row.id,
+        action.actionId || action.id,
+        action.name, action.nameEn || null,
+        action.messageTemplate || null, action.messageTemplateEn || null,
+        action.defaultMessage || null, action.defaultMessageEn || null
+      );
+    }
+  }
+});
+
+/**
+ * Transform DB rows into the API response format.
+ */
+function transformRole(roleRow, actionRows) {
+  return {
+    id: roleRow.role_id,
+    name: roleRow.name,
+    fullName: roleRow.full_name,
+    title: roleRow.title,
+    titleEn: roleRow.title_en,
+    groupId: roleRow.group_id,
+    icon: roleRow.icon,
+    messagePrefix: roleRow.message_prefix,
+    messagePrefixEn: roleRow.message_prefix_en,
+    createdAt: roleRow.created_at,
+    updatedAt: roleRow.updated_at,
+    actions: actionRows.map(a => ({
+      id: a.action_id,
+      name: a.name,
+      nameEn: a.name_en,
+      messageTemplate: a.message_template,
+      messageTemplateEn: a.message_template_en,
+      defaultMessage: a.default_message,
+      defaultMessageEn: a.default_message_en
+    }))
+  };
+}
+
+export const expertDb = {
+  /**
+   * Get all custom roles for a user, with nested actions.
+   */
+  getCustomRolesByUser(userId) {
+    const rows = stmts.getRolesByUser.all(userId);
+    return rows.map(row => {
+      const actions = stmts.getActionsByRole.all(row.id);
+      return transformRole(row, actions);
+    });
+  },
+
+  /**
+   * Create a custom role with actions (transactional).
+   * @returns {{ rowId: string, roleId: string }}
+   */
+  createCustomRole(userId, roleData) {
+    return insertRoleWithActions(userId, roleData);
+  },
+
+  /**
+   * Update a custom role and replace its actions (transactional).
+   */
+  updateCustomRole(userId, roleId, roleData) {
+    updateRoleWithActions(userId, roleId, roleData);
+  },
+
+  /**
+   * Delete a custom role (CASCADE deletes actions).
+   * @returns {boolean} true if deleted
+   */
+  deleteCustomRole(userId, roleId) {
+    const result = stmts.deleteRole.run(userId, roleId);
+    return result.changes > 0;
+  },
+
+  /**
+   * Check if a role exists for a user.
+   */
+  exists(userId, roleId) {
+    return !!stmts.getRoleByUserAndId.get(userId, roleId);
+  }
+};

package/local-runtime/server/db/identity-db.js

@@ -0,0 +1,92 @@
+import { randomUUID } from 'crypto';
+import { stmts } from './connection.js';
+
+/**
+ * CRUD operations for user_identities — multi-provider SSO bindings.
+ *
+ * One internal user can have many identities (one per provider). The
+ * UNIQUE(provider, subject) constraint enforces that a single provider
+ * account (e.g. one GitHub account) can only be bound to one user.
+ */
+export const identityDb = {
+  /**
+   * Create a new identity row binding (user_id ↔ provider/subject).
+   * Returns the inserted row, or null if the (provider, subject) is already
+   * taken by another user (UNIQUE conflict).
+   */
+  create({ userId, provider, subject, email = null, displayName = null }) {
+    const id = `idn_${randomUUID()}`;
+    const now = Date.now();
+    try {
+      stmts.insertIdentity.run(id, userId, provider, subject, email, displayName, now, now);
+      return { id, user_id: userId, provider, subject, email, display_name: displayName, created_at: now, last_login_at: now };
+    } catch (err) {
+      if (err && /UNIQUE/i.test(err.message || '')) return null;
+      throw err;
+    }
+  },
+
+  /**
+   * Find the identity row for (provider, subject), or null.
+   */
+  findBySubject(provider, subject) {
+    if (!provider || !subject) return null;
+    return stmts.getIdentityBySubject.get(provider, subject) || null;
+  },
+
+  /**
+   * Find a user's identity row for a specific provider, or null.
+   */
+  findForUser(userId, provider) {
+    return stmts.getIdentityForUser.get(userId, provider) || null;
+  },
+
+  /**
+   * List all identities for a user.
+   */
+  listForUser(userId) {
+    return stmts.getIdentitiesByUser.all(userId);
+  },
+
+  /**
+   * Count how many identities a user has bound.
+   */
+  countForUser(userId) {
+    const row = stmts.countIdentitiesByUser.get(userId);
+    return Number(row?.count || 0);
+  },
+
+  /**
+   * Update last_login_at for an identity row.
+   */
+  touchLogin(id) {
+    stmts.updateIdentityLogin.run(Date.now(), id);
+  },
+
+  /**
+   * Remove a user's binding to a provider. Returns true if a row was deleted.
+   */
+  removeForUser(userId, provider) {
+    const res = stmts.deleteIdentityForUser.run(userId, provider);
+    return Number(res?.changes || 0) > 0;
+  },
+
+  /**
+   * Idempotent upsert keyed by (provider, subject):
+   * - If a row already exists for that subject, return it (do not move it to a different user).
+   * - Otherwise create a new row bound to userId.
+   *
+   * Returns { row, created } so callers can tell whether the binding was new.
+   */
+  upsert({ userId, provider, subject, email = null, displayName = null }) {
+    const existing = this.findBySubject(provider, subject);
+    if (existing) {
+      stmts.updateIdentityLogin.run(Date.now(), existing.id);
+      return { row: existing, created: false };
+    }
+    const row = this.create({ userId, provider, subject, email, displayName });
+    return { row, created: !!row };
+  }
+};
+
+export default identityDb;

package/local-runtime/server/db/invitation-db.js

@@ -0,0 +1,38 @@
+import { randomBytes } from 'crypto';
+import { stmts } from './connection.js';
+
+// 定期清理过期邀请码（每小时）
+setInterval(() => {
+  try { stmts.cleanupExpiredInvitations.run(Date.now()); } catch (e) { /* ignore */ }
+}, 60 * 60 * 1000);
+
+export const invitationDb = {
+  create(createdBy, role = 'user', expiresInMs = 7 * 24 * 60 * 60 * 1000) {
+    const code = randomBytes(6).toString('hex'); // 12 字符
+    const now = Date.now();
+    const expiresAt = now + expiresInMs;
+    stmts.insertInvitation.run(code, createdBy, now, expiresAt, role);
+    return { code, createdBy, createdAt: now, expiresAt, role };
+  },
+
+  get(code) {
+    return stmts.getInvitation.get(code) || null;
+  },
+
+  use(code, usedBy) {
+    stmts.useInvitation.run(usedBy, Date.now(), code);
+  },
+
+  getByUser(userId) {
+    return stmts.getInvitationsByUser.all(userId);
+  },
+
+  delete(code, userId) {
+    const result = stmts.deleteInvitation.run(code, userId);
+    return result.changes > 0;
+  },
+
+  cleanup() {
+    stmts.cleanupExpiredInvitations.run(Date.now());
+  }
+};

package/local-runtime/server/db/message-db.js

@@ -0,0 +1,257 @@
+import db from './connection.js';
+import { stmts, transaction } from './connection.js';
+
+export const messageDb = {
+  add(sessionId, role, content, messageType = null, toolName = null, toolInput = null, metadata = null) {
+    const now = Date.now();
+    const result = stmts.insertMessage.run(sessionId, role, content, messageType, toolName, toolInput, now, metadata);
+    // 更新会话的 updated_at
+    // fix-chat-title-sticky: updateSession statement gained a fifth
+    // placeholder for `is_custom_title` — pass null so COALESCE keeps
+    // the existing value. Forgetting this arg is a RangeError on every
+    // message insert.
+    stmts.updateSession.run(null, null, null, now, sessionId);
+    return result.lastInsertRowid;
+  },
+
+  getBySession(sessionId) {
+    return stmts.getMessagesBySession.all(sessionId);
+  },
+
+  getRecent(sessionId, limit = 50) {
+    return stmts.getRecentMessages.all(sessionId, limit).reverse();
+  },
+
+  getAfterId(sessionId, afterId) {
+    return stmts.getMessagesAfterId.all(sessionId, afterId || 0);
+  },
+
+  getBeforeId(sessionId, beforeId, limit = 50) {
+    return stmts.getMessagesBeforeId.all(sessionId, beforeId, limit).reverse();
+  },
+
+  getRecentTurns(sessionId, turnCount = 5) {
+    const userIds = stmts.getRecentUserMessageIds.all(sessionId, turnCount);
+    if (userIds.length === 0) return { messages: [], hasMore: false };
+    const oldestUserId = userIds[userIds.length - 1].id;
+    const messages = stmts.getMessagesFromId.all(sessionId, oldestUserId);
+    const hasMore = stmts.getMessagesBeforeId.all(sessionId, oldestUserId, 1).length > 0;
+    return { messages, hasMore };
+  },
+
+  getTurnsBeforeId(sessionId, beforeId, turnCount = 5) {
+    const userIds = stmts.getUserMessageIdsBeforeId.all(sessionId, beforeId, turnCount);
+    if (userIds.length === 0) return { messages: [], hasMore: false };
+    const oldestUserId = userIds[userIds.length - 1].id;
+    const messages = stmts.getMessagesBetweenIds.all(sessionId, oldestUserId, beforeId);
+    const hasMore = stmts.getMessagesBeforeId.all(sessionId, oldestUserId, 1).length > 0;
+    return { messages, hasMore };
+  },
+
+  getLastUserMessage(sessionId) {
+    return stmts.getLastUserMessage.get(sessionId) || null;
+  },
+
+  bulkAddHistory(sessionId, historyMessages) {
+    function extractUserText(msg) {
+      const content = msg.message?.content;
+      if (!content) return '';
+      return typeof content === 'string'
+        ? content
+        : (Array.isArray(content) ? content.map(b => b.text || '').join('') : JSON.stringify(content));
+    }
+
+    // Detect compact summary messages injected by Claude CLI after context compaction.
+    // These arrive as type:'user' but contain AI-generated context summaries, not real user input.
+    function isCompactSummary(text) {
+      if (!text) return false;
+      return (text.includes('<context>') && text.includes('</context>'))
+        || text.startsWith('Here is a summary of the conversation')
+        || text.includes('<compact-summary>')
+        || text.includes('This session is being continued from a previous conversation');
+    }
+
+    function rowsFromHistory(msgs) {
+      const rows = [];
+      let lastTs = 0;
+      for (const msg of msgs) {
+        const rawTs = msg.timestamp ? new Date(msg.timestamp).getTime() : 0;
+        const ts = rawTs > lastTs ? rawTs : lastTs + 1;
+        lastTs = ts;
+
+        if (msg.type === 'user') {
+          const text = extractUserText(msg);
+          if (!text || isCompactSummary(text)) continue;
+          rows.push({ role: 'user', content: text, messageType: 'user', toolName: null, toolInput: null, ts });
+        } else if (msg.type === 'assistant') {
+          const content = msg.message?.content;
+          if (!content || !Array.isArray(content)) continue;
+          for (const block of content) {
+            if (block.type === 'text' && block.text) {
+              rows.push({ role: 'assistant', content: block.text, messageType: 'assistant', toolName: null, toolInput: null, ts });
+            } else if (block.type === 'tool_use') {
+              const toolInput = JSON.stringify(block.input || {});
+              rows.push({
+                role: 'assistant',
+                content: toolInput,
+                messageType: 'tool_use',
+                toolName: block.name,
+                toolInput,
+                ts,
+              });
+            }
+          }
+        }
+      }
+      return rows;
+    }
+
+    function rowSignature(row) {
+      return [row.role, row.content, row.messageType, row.toolName || '', row.toolInput || ''].join('\0');
+    }
+
+    function dbRowSignature(row) {
+      return [row.role, row.content, row.message_type, row.tool_name || '', row.tool_input || ''].join('\0');
+    }
+
+    function rowsMatchDbRows(dbRows, historyRows) {
+      if (dbRows.length !== historyRows.length) return false;
+      for (let i = 0; i < historyRows.length; i++) {
+        if (dbRowSignature(dbRows[i]) !== rowSignature(historyRows[i])) return false;
+      }
+      return true;
+    }
+
+    function historyRowsContainToolUse(rows) {
+      return rows.some(row => row.messageType === 'tool_use');
+    }
+
+    function tailLooksLikeStaleToolAction(dbRows) {
+      return dbRows.some(row => {
+        if (row.role !== 'assistant' || row.message_type !== 'assistant') return false;
+        const text = String(row.content || '').trimStart();
+        return /^(call|tool_call|function_call|server_tool_use)(?:\r?\n|$)/.test(text);
+      });
+    }
+
+    let msgsToInsert = historyMessages;
+    const lastUserMsg = this.getLastUserMessage(sessionId);
+    let needsRebuild = false;
+    let replaceTailAfterId = null;
+
+    if (lastUserMsg) {
+      const tsRange = stmts.getTimestampRange.get(sessionId);
+      // feat-chat-load-perf: the timestamp-range heuristic is a one-shot repair,
+      // not a per-resume hot path. The repair itself produces densely packed
+      // `ts = lastTs + 1` rows, which re-pass the (< 1000ms) test on every
+      // future resume — so without a sentinel the user pays a full DELETE +
+      // re-INSERT of the entire session on EVERY chat open. The sentinel
+      // `sessions.ts_rebuilt_at` is set to Date.now() the first (and only)
+      // time the repair fires; subsequent resumes see non-zero and skip it,
+      // falling through to the cheap anchor-based delta append below.
+      if (tsRange && tsRange.count > 5 && (tsRange.max_ts - tsRange.min_ts) < 1000) {
+        const sentinelRow = stmts.getSessionTsRebuiltAt.get(sessionId);
+        const alreadyRebuilt = sentinelRow && sentinelRow.ts_rebuilt_at > 0;
+        if (alreadyRebuilt) {
+          // Quiet by default — every once-repaired session would otherwise log
+          // this line on every future chat-resume forever, exactly inverting
+          // the perf goal. Flip DEBUG_BULK_HISTORY to see it.
+          if (process.env.DEBUG_BULK_HISTORY) {
+            console.log(`[bulkAddHistory] Skipping rebuild for ${sessionId} (one-shot guard, ts_rebuilt_at=${sentinelRow.ts_rebuilt_at})`);
+          }
+        } else {
+          console.log(`[bulkAddHistory] Detected bad timestamps (range: ${tsRange.max_ts - tsRange.min_ts}ms for ${tsRange.count} msgs), rebuilding for ${sessionId} (will delete ${tsRange.count} rows)`);
+          needsRebuild = true;
+        }
+      }
+      if (!needsRebuild) {
+        const anchor = lastUserMsg.content;
+        let anchorIndex = -1;
+
+        for (let i = historyMessages.length - 1; i >= 0; i--) {
+          const msg = historyMessages[i];
+          if (msg.type === 'user') {
+            const text = extractUserText(msg);
+            if (text === anchor) {
+              anchorIndex = i;
+              break;
+            }
+          }
+        }
+
+        if (anchorIndex === -1) {
+          console.log(`[bulkAddHistory] Anchor not found in history, appending all ${historyMessages.length} messages for ${sessionId}`);
+        } else {
+          let nextTurnStart = -1;
+          for (let i = anchorIndex + 1; i < historyMessages.length; i++) {
+            if (historyMessages[i].type === 'user') {
+              nextTurnStart = i;
+              break;
+            }
+          }
+
+          if (nextTurnStart === -1) {
+            // The active/latest turn has no following user anchor. Older code returned
+            // here, so a tail that had been stored with a stale Claude Code shape
+            // (for example raw `call`/id/argument text rows) could never heal on
+            // refresh. Compare the persisted tail after the last user row with the
+            // normalized JSONL tail; replace it only when it differs.
+            const tailMessages = historyMessages.slice(anchorIndex + 1);
+            const desiredTailRows = rowsFromHistory(tailMessages);
+            if (desiredTailRows.length === 0) return 0;
+            if (!historyRowsContainToolUse(desiredTailRows)) return 0;
+            const currentTailRows = stmts.getMessagesAfterId.all(sessionId, lastUserMsg.id);
+            if (rowsMatchDbRows(currentTailRows, desiredTailRows)) return 0;
+            if (!tailLooksLikeStaleToolAction(currentTailRows)) return 0;
+            replaceTailAfterId = lastUserMsg.id;
+            msgsToInsert = tailMessages;
+          } else {
+            msgsToInsert = historyMessages.slice(nextTurnStart);
+          }
+        }
+      }
+    }
+
+    const insertMany = transaction((msgs) => {
+      if (needsRebuild) {
+        stmts.deleteMessagesBySession.run(sessionId);
+        // Stamp the sentinel inside the same transaction as DELETE + re-INSERT.
+        // SQLite is atomic, so either everything (rows + stamp) lands or
+        // nothing does — preventing the "rows rebuilt but stamp lost ⇒
+        // rebuild loops forever on every future resume" failure mode that
+        // motivated this entire change.
+        stmts.markSessionTsRebuilt.run(Date.now(), sessionId);
+      } else if (replaceTailAfterId != null) {
+        stmts.deleteMessagesAfterId.run(sessionId, replaceTailAfterId);
+      }
+
+      const rows = rowsFromHistory(msgs);
+      for (const row of rows) {
+        stmts.insertMessage.run(
+          sessionId,
+          row.role,
+          row.content,
+          row.messageType,
+          row.toolName,
+          row.toolInput,
+          row.ts,
+          null
+        );
+      }
+      return rows.length;
+    });
+    return insertMany(msgsToInsert);
+  },
+
+  getCount(sessionId) {
+    return stmts.getMessageCount.get(sessionId)?.count || 0;
+  },
+
+  updateMetadata(messageId, metadata) {
+    stmts.updateMessageMetadata.run(metadata, messageId);
+  },
+
+  deleteBySession(sessionId) {
+    stmts.deleteMessagesBySession.run(sessionId);
+  }
+};

package/local-runtime/server/db/session-db.js

@@ -0,0 +1,118 @@
+import { stmts } from './connection.js';
+import { trackSession } from '../context.js';
+
+/**
+ * Map a raw row from the `sessions` table into the camelCase shape the
+ * rest of the server uses. Every consumer that calls one of the read
+ * helpers below must go through this so the sticky `customTitle` bit
+ * is consistently surfaced.
+ *
+ * fix-chat-title-sticky: before this helper existed, callers read
+ * `row.title` directly and the `is_custom_title` column was invisible,
+ * which is why every rebuild path (agent-conversation,
+ * agent-sync, get_agents) ended up wiping the sticky bit.
+ */
+function mapRow(row) {
+  if (!row) return row;
+  return {
+    ...row,
+    customTitle: row.is_custom_title === 1
+  };
+}
+
+export const sessionDb = {
+  create(id, agentId, agentName, workDir, claudeSessionId = null, title = null, userId = null, provider = null) {
+    const now = Date.now();
+    stmts.insertSession.run(id, userId, agentId, agentName, claudeSessionId, workDir, title, provider, now, now);
+    trackSession(userId);
+    return { id, userId, agentId, agentName, workDir, claudeSessionId, title, provider, customTitle: false, createdAt: now, updatedAt: now };
+  },
+
+  /**
+   * Partial update. Pass `isCustomTitle: 1` (along with `title`) when the
+   * change came from the user-rename UI; pass `isCustomTitle: 0` to
+   * explicitly clear the bit. Omit it (or pass `undefined`) on auto-title
+   * writes — the `COALESCE` keeps the existing column value, which is the
+   * whole point of the sticky behaviour.
+   */
+  update(id, updates = {}) {
+    const now = Date.now();
+    stmts.updateSession.run(
+      updates.claudeSessionId ?? null,
+      updates.title ?? null,
+      updates.isCustomTitle ?? null,
+      now,
+      id
+    );
+  },
+
+  setActive(id, active) {
+    stmts.updateSessionActive.run(active ? 1 : 0, Date.now(), id);
+  },
+
+  /**
+   * fix-session-dup: re-point a session at a different owning agent.
+   * The caller MUST have already removed the conv from the old
+   * agent's in-memory `agent.conversations` Map; this updates the
+   * persisted owner so a future `get_agents` restore re-seats the
+   * conv only on the new agent.
+   *
+   * `agentName` is denormalized in the row (legacy schema), so we
+   * write both columns together to keep them in sync — otherwise
+   * the next `agent_list` broadcast would surface a stale name.
+   */
+  setAgent(id, agentId, agentName) {
+    stmts.updateSessionAgent.run(agentId, agentName ?? null, Date.now(), id);
+  },
+
+  setPinned(id, pinned) {
+    stmts.updateSessionPinned.run(pinned ? 1 : 0, Date.now(), id);
+  },
+
+  /**
+   * fix-copilot-provider-persist: persist the conversation's code-agent
+   * provider (e.g. 'copilot') so it survives an agent process restart.
+   * Only meaningful for non-default providers; a null/'claude-code' value
+   * is the implicit default and need not be stored, but we still accept it
+   * so callers can clear the column if a provider ever changes.
+   */
+  setProvider(id, provider) {
+    stmts.updateSessionProvider.run(provider ?? null, Date.now(), id);
+  },
+
+  get(id) {
+    return mapRow(stmts.getSession.get(id));
+  },
+
+  getByAgent(agentId, limit = 50) {
+    return stmts.getSessionsByAgent.all(agentId, limit).map(mapRow);
+  },
+
+  getByUser(userId, limit = 50) {
+    return stmts.getSessionsByUser.all(userId, limit).map(mapRow);
+  },
+
+  getByUserAndAgent(userId, agentId, limit = 50) {
+    return stmts.getSessionsByUserAndAgent.all(userId, agentId, limit).map(mapRow);
+  },
+
+  getAll(limit = 100) {
+    return stmts.getAllSessions.all(limit).map(mapRow);
+  },
+
+  getActive() {
+    return stmts.getActiveSessions.all().map(mapRow);
+  },
+
+  getActiveByUser(userId) {
+    return stmts.getActiveSessionsByUser.all(userId).map(mapRow);
+  },
+
+  delete(id) {
+    stmts.deleteSession.run(id);
+  },
+
+  exists(id) {
+    return !!stmts.getSession.get(id);
+  }
+};